kailogger 1.0.1-dark.red → 1.0.2

package/src/styles/KaiChroma.ts

@@ -0,0 +1,370 @@
+import os from 'os';
+
+export type Color = [number, number, number];
+export type HexColor = string;
+export type RgbColor = { r: number; g: number; b: number };
+export type HslColor = { h: number; s: number; l: number };
+export type ColorStop = { color: string; position: number };
+export type GradientOptions = {
+  interpolation?: 'linear' | 'ease' | 'bezier' | 'smooth';
+  direction?: 'horizontal' | 'vertical' | 'diagonal';
+  stops?: ColorStop[];
+};
+export type StyleOptions = {
+  bold?: boolean;
+  dim?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  inverse?: boolean;
+  strikethrough?: boolean;
+  blink?: boolean;
+  hidden?: boolean;
+};
+const env = process.env;
+const isTTY = process.stdout.isTTY;
+const platform = os.platform();
+const supportLevel = (() => {
+  if (env.CI && !env.FORCE_COLOR) return 0;
+  if (!isTTY && !env.FORCE_COLOR) return 0;
+  if (env.FORCE_COLOR === '0') return 0;
+  if (env.FORCE_COLOR === '1') return 1;
+  if (env.FORCE_COLOR === '2') return 2;
+  if (env.FORCE_COLOR === '3') return 3;
+  if (platform === 'win32') {
+    if (env.WT_SESSION || env.ConEmuANSI === 'ON') return 3;
+  }
+  if (env.COLORTERM === 'truecolor' || env.COLORTERM === '24bit') return 3;
+  if (env.TERM_PROGRAM === 'iTerm.app') return 3;
+  if (env.TERM_PROGRAM === 'Apple_Terminal') return 2;
+  if (env.TERM_PROGRAM === 'Hyper') return 3;
+  if (env.TERM_PROGRAM === 'vscode') return 3;
+  const term = env.TERM || '';
+  if (term.includes('truecolor') || term.includes('24bit')) return 3;
+  if (term.includes('256color')) return 2;
+  if (term === 'xterm' || term === 'screen' || term === 'linux') return 1;
+  return isTTY ? 1 : 0;
+})();
+export class KaiChroma {
+  private static cache = new Map<string, string>();
+  private static readonly MAX_CACHE_SIZE = 1000;
+  private static hexToRgb(hex: string): Color {
+    const cleanHex = hex.replace(/^#/, '');
+    const bigint = parseInt(cleanHex, 16);
+    return [(bigint >> 16) & 255, (bigint >> 8) & 255, bigint & 255];
+  }
+  private static rgbToHex(r: number, g: number, b: number): string {
+    return '#' + [r, g, b].map(x => {
+      const hex = x.toString(16);
+      return hex.length === 1 ? '0' + hex : hex;
+    }).join('');
+  }
+  private static rgbToHsl(r: number, g: number, b: number): HslColor {
+    r /= 255; g /= 255; b /= 255;
+    const max = Math.max(r, g, b), min = Math.min(r, g, b);
+    let h = 0, s = 0, l = (max + min) / 2;
+    if (max !== min) {
+      const d = max - min;
+      s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+      switch (max) {
+        case r: h = ((g - b) / d + (g < b ? 6 : 0)) / 6; break;
+        case g: h = ((b - r) / d + 2) / 6; break;
+        case b: h = ((r - g) / d + 4) / 6; break;
+      }
+    }
+    return { h: h * 360, s: s * 100, l: l * 100 };
+  }
+  private static hslToRgb(h: number, s: number, l: number): Color {
+    h /= 360; s /= 100; l /= 100;
+    const hue2rgb = (p: number, q: number, t: number) => {
+      if (t < 0) t += 1;
+      if (t > 1) t -= 1;
+      if (t < 1/6) return p + (q - p) * 6 * t;
+      if (t < 1/2) return q;
+      if (t < 2/3) return p + (q - p) * (2/3 - t) * 6;
+      return p;
+    };
+    if (s === 0) {
+      const val = Math.round(l * 255);
+      return [val, val, val];
+    }
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    return [
+      Math.round(hue2rgb(p, q, h + 1/3) * 255),
+      Math.round(hue2rgb(p, q, h) * 255),
+      Math.round(hue2rgb(p, q, h - 1/3) * 255)
+    ];
+  }
+  private static rgbToAnsi256(r: number, g: number, b: number): number {
+    if (r === g && g === b) {
+      if (r < 8) return 16;
+      if (r > 248) return 231;
+      return Math.round(((r - 8) / 247) * 24) + 232;
+    }
+    return 16 + (36 * Math.round(r / 255 * 5)) + (6 * Math.round(g / 255 * 5)) + Math.round(b / 255 * 5);
+  }
+  private static interpolateLinear(start: Color, end: Color, t: number): Color {
+    return [
+      Math.round(start[0] + (end[0] - start[0]) * t),
+      Math.round(start[1] + (end[1] - start[1]) * t),
+      Math.round(start[2] + (end[2] - start[2]) * t)
+    ];
+  }
+  private static interpolateEase(start: Color, end: Color, t: number): Color {
+    const eased = t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+    return this.interpolateLinear(start, end, eased);
+  }
+  private static interpolateBezier(start: Color, end: Color, t: number): Color {
+    const bezier = t * t * (3 - 2 * t);
+    return this.interpolateLinear(start, end, bezier);
+  }
+  private static interpolateSmooth(start: Color, end: Color, t: number): Color {
+    const smooth = t * t * t * (t * (t * 6 - 15) + 10);
+    return this.interpolateLinear(start, end, smooth);
+  }
+  static hex(hex: string, text: string): string {
+    if (supportLevel === 0) return text;
+    const cacheKey = `hex:${hex}:${supportLevel}`;
+    const [r, g, b] = this.hexToRgb(hex);
+    if (supportLevel === 3) {
+      return `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`;
+    } else if (supportLevel === 2) {
+      return `\x1b[38;5;${this.rgbToAnsi256(r, g, b)}m${text}\x1b[39m`;
+    }
+    return text;
+  }
+  static rgb(r: number, g: number, b: number, text: string): string {
+    if (supportLevel === 0) return text;
+    if (supportLevel === 3) {
+      return `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`;
+    } else if (supportLevel === 2) {
+      return `\x1b[38;5;${this.rgbToAnsi256(r, g, b)}m${text}\x1b[39m`;
+    }
+    return text;
+  }
+  static hsl(h: number, s: number, l: number, text: string): string {
+    const [r, g, b] = this.hslToRgb(h, s, l);
+    return this.rgb(r, g, b, text);
+  }
+  static bgHex(hex: string, text: string): string {
+    if (supportLevel === 0) return text;
+    const [r, g, b] = this.hexToRgb(hex);
+    if (supportLevel === 3) {
+      return `\x1b[48;2;${r};${g};${b}m${text}\x1b[49m`;
+    } else if (supportLevel === 2) {
+      return `\x1b[48;5;${this.rgbToAnsi256(r, g, b)}m${text}\x1b[49m`;
+    }
+    return text;
+  }
+  static bgRgb(r: number, g: number, b: number, text: string): string {
+    if (supportLevel === 0) return text;
+    if (supportLevel === 3) {
+      return `\x1b[48;2;${r};${g};${b}m${text}\x1b[49m`;
+    } else if (supportLevel === 2) {
+      return `\x1b[48;5;${this.rgbToAnsi256(r, g, b)}m${text}\x1b[49m`;
+    }
+    return text;
+  }
+  static bold(text: string): string { return `\x1b[1m${text}\x1b[22m`; }
+  static dim(text: string): string { return `\x1b[2m${text}\x1b[22m`; }
+  static italic(text: string): string { return `\x1b[3m${text}\x1b[23m`; }
+  static underline(text: string): string { return `\x1b[4m${text}\x1b[24m`; }
+  static inverse(text: string): string { return `\x1b[7m${text}\x1b[27m`; }
+  static hidden(text: string): string { return `\x1b[8m${text}\x1b[28m`; }
+  static strikethrough(text: string): string { return `\x1b[9m${text}\x1b[29m`; }
+  static blink(text: string): string { return `\x1b[5m${text}\x1b[25m`; }
+  static style(text: string, options: StyleOptions): string {
+    let result = text;
+    if (options.bold) result = this.bold(result);
+    if (options.dim) result = this.dim(result);
+    if (options.italic) result = this.italic(result);
+    if (options.underline) result = this.underline(result);
+    if (options.inverse) result = this.inverse(result);
+    if (options.strikethrough) result = this.strikethrough(result);
+    if (options.blink) result = this.blink(result);
+    if (options.hidden) result = this.hidden(result);
+    return result;
+  }
+  static gradient(colors: string[], text: string, options: GradientOptions = {}): string {
+    if (supportLevel === 0) return text;
+    if (colors.length < 2) return this.hex(colors[0] || '#ffffff', text);
+    const interpolation = options.interpolation || 'linear';
+    const rgbColors = colors.map(c => this.hexToRgb(c));
+    const chars = [...text];
+    const steps = chars.length;
+    let output = '';
+    const interpolate = (start: Color, end: Color, t: number): Color => {
+      switch (interpolation) {
+        case 'ease': return this.interpolateEase(start, end, t);
+        case 'bezier': return this.interpolateBezier(start, end, t);
+        case 'smooth': return this.interpolateSmooth(start, end, t);
+        default: return this.interpolateLinear(start, end, t);
+      }
+    };
+    chars.forEach((char, i) => {
+      const t = steps <= 1 ? 0 : i / (steps - 1);
+      const segmentLength = 1 / (rgbColors.length - 1);
+      const segmentIndex = Math.min(Math.floor(t / segmentLength), rgbColors.length - 2);
+      const segmentT = (t - (segmentIndex * segmentLength)) / segmentLength;
+      const [r, g, b] = interpolate(rgbColors[segmentIndex], rgbColors[segmentIndex + 1], segmentT);
+      if (supportLevel === 3) {
+        output += `\x1b[38;2;${r};${g};${b}m${char}`;
+      } else if (supportLevel === 2) {
+        output += `\x1b[38;5;${this.rgbToAnsi256(r, g, b)}m${char}`;
+      } else {
+        output += char;
+      }
+    });
+    return output + '\x1b[39m';
+  }
+  static rainbowGradient(text: string): string {
+    return this.gradient(
+      ['#FF0000', '#FF7F00', '#FFFF00', '#00FF00', '#0000FF', '#4B0082', '#9400D3'],
+      text,
+      { interpolation: 'smooth' }
+    );
+  }
+  static sunsetGradient(text: string): string {
+    return this.gradient(['#FF512F', '#F09819', '#FFD89B'], text, { interpolation: 'ease' });
+  }
+  static oceanGradient(text: string): string {
+    return this.gradient(['#667eea', '#764ba2', '#f093fb'], text, { interpolation: 'bezier' });
+  }
+  static fireGradient(text: string): string {
+    return this.gradient(['#ff0000', '#ff4500', '#ffa500', '#ffff00'], text, { interpolation: 'smooth' });
+  }
+  static matrixGradient(text: string): string {
+    return this.gradient(['#00ff00', '#00cc00', '#009900'], text, { interpolation: 'linear' });
+  }
+  static lighten(hex: string, amount: number): string {
+    const [r, g, b] = this.hexToRgb(hex);
+    const hsl = this.rgbToHsl(r, g, b);
+    hsl.l = Math.min(100, hsl.l + amount);
+    const [nr, ng, nb] = this.hslToRgb(hsl.h, hsl.s, hsl.l);
+    return this.rgbToHex(nr, ng, nb);
+  }
+  static darken(hex: string, amount: number): string {
+    return this.lighten(hex, -amount);
+  }
+  static saturate(hex: string, amount: number): string {
+    const [r, g, b] = this.hexToRgb(hex);
+    const hsl = this.rgbToHsl(r, g, b);
+    hsl.s = Math.min(100, hsl.s + amount);
+    const [nr, ng, nb] = this.hslToRgb(hsl.h, hsl.s, hsl.l);
+    return this.rgbToHex(nr, ng, nb);
+  }
+  static desaturate(hex: string, amount: number): string {
+    return this.saturate(hex, -amount);
+  }
+  static rotate(hex: string, degrees: number): string {
+    const [r, g, b] = this.hexToRgb(hex);
+    const hsl = this.rgbToHsl(r, g, b);
+    hsl.h = (hsl.h + degrees) % 360;
+    if (hsl.h < 0) hsl.h += 360;
+    const [nr, ng, nb] = this.hslToRgb(hsl.h, hsl.s, hsl.l);
+    return this.rgbToHex(nr, ng, nb);
+  }
+  static mix(hex1: string, hex2: string, weight: number = 0.5): string {
+    const [r1, g1, b1] = this.hexToRgb(hex1);
+    const [r2, g2, b2] = this.hexToRgb(hex2);
+    const [r, g, b] = this.interpolateLinear([r1, g1, b1], [r2, g2, b2], weight);
+    return this.rgbToHex(r, g, b);
+  }
+  static analogous(hex: string, count: number = 3): string[] {
+    const palette: string[] = [hex];
+    const step = 30;
+    for (let i = 1; i < count; i++) {
+      palette.push(this.rotate(hex, step * i));
+    }
+    return palette;
+  }
+  static complementary(hex: string): string[] {
+    return [hex, this.rotate(hex, 180)];
+  }
+  static triadic(hex: string): string[] {
+    return [hex, this.rotate(hex, 120), this.rotate(hex, 240)];
+  }
+  static tetradic(hex: string): string[] {
+    return [hex, this.rotate(hex, 90), this.rotate(hex, 180), this.rotate(hex, 270)];
+  }
+  static monochromatic(hex: string, count: number = 5): string[] {
+    const palette: string[] = [];
+    const step = 100 / (count - 1);
+    for (let i = 0; i < count; i++) {
+      palette.push(this.lighten(hex, -50 + step * i));
+    }
+    return palette;
+  }
+  static strip(text: string): string {
+    return text.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+  }
+  static getSupport(): number {
+    return supportLevel;
+  }
+  static getSupportName(): string {
+    const names = ['none', 'basic', '256', 'truecolor'];
+    return names[supportLevel];
+  }
+  static isSupported(): boolean {
+    return supportLevel > 0;
+  }
+  static textLength(text: string): number {
+    return this.strip(text).length;
+  }
+  static box(text: string, color: string = '#ffffff', padding: number = 1): string {
+    const lines = text.split('\n');
+    const maxLen = Math.max(...lines.map(l => this.textLength(l)));
+    const pad = ' '.repeat(padding);
+    const width = maxLen + padding * 2;
+    const top = this.hex(color, '┌' + '─'.repeat(width) + '┐');
+    const bottom = this.hex(color, '└' + '─'.repeat(width) + '┘');
+    const content = lines.map(line => {
+      const spaces = ' '.repeat(maxLen - this.textLength(line));
+      return this.hex(color, '│') + pad + line + spaces + pad + this.hex(color, '│');
+    }).join('\n');
+    return `${top}\n${content}\n${bottom}`;
+  }
+  static wave(text: string, colors: string[]): string {
+    if (supportLevel === 0) return text;
+    const chars = [...text];
+    const rgbColors = colors.map(c => this.hexToRgb(c));
+    let output = '';
+    chars.forEach((char, i) => {
+      const colorIndex = Math.floor((Math.sin(i * 0.5) + 1) * (rgbColors.length - 1) / 2);
+      const [r, g, b] = rgbColors[colorIndex];
+      if (supportLevel === 3) {
+        output += `\x1b[38;2;${r};${g};${b}m${char}`;
+      } else if (supportLevel === 2) {
+        output += `\x1b[38;5;${this.rgbToAnsi256(r, g, b)}m${char}`;
+      } else {
+        output += char;
+      }
+    });
+
+    return output + '\x1b[39m';
+  }
+  static pulse(text: string, color: string, frames: number = 10): string[] {
+    const result: string[] = [];
+    const [r, g, b] = this.hexToRgb(color);
+    for (let i = 0; i < frames; i++) {
+      const brightness = (Math.sin((i / frames) * Math.PI * 2) + 1) / 2;
+      const adjustedR = Math.round(r * brightness);
+      const adjustedG = Math.round(g * brightness);
+      const adjustedB = Math.round(b * brightness);
+      result.push(this.rgb(adjustedR, adjustedG, adjustedB, text));
+    }
+    return result;
+  }
+  private static clearCacheIfNeeded(): void {
+    if (this.cache.size > this.MAX_CACHE_SIZE) {
+      const entriesToDelete = this.cache.size - this.MAX_CACHE_SIZE / 2;
+      const iterator = this.cache.keys();
+      for (let i = 0; i < entriesToDelete; i++) {
+        const key = iterator.next().value;
+        if (key) this.cache.delete(key);
+      }
+    }
+  }
+}
+
+export default KaiChroma;

package/src/styles/palettes.ts

@@ -1,58 +1,210 @@
-export const palettes = {
+
+import { KaiChroma } from './KaiChroma';
+
+export type ThemeName = 
+    | 'zen' 
+    | 'neon' 
+    | 'pastel' 
+    | 'hacker' 
+    | 'sunset' 
+    | 'ocean' 
+    | 'cyberpunk' 
+    | 'dracula' 
+    | 'monokai' 
+    | 'vaporwave' 
+    | 'midnight' 
+    | 'forest'
+    | 'volcano'
+    | 'gold';
+
+export interface Theme {
+    success: string[]; // Gradient colors
+    error: string[];
+    warning: string[];
+    info: string[];
+    debug: string[];
+    text: string;     // Base text color
+    dim: string;      // Dimmed color
+    accent: string;   // Special accent
+    bg?: string;      // Background recommendation
+}
+
+export const palettes: Record<ThemeName, Theme> = {
+    // 1. Zen (Minimalist, calming)
     zen: {
         success: ['#00b09b', '#96c93d'],
         error: ['#ff416c', '#ff4b2b'],
         warning: ['#f7971e', '#ffd200'],
         info: ['#2193b0', '#6dd5ed'],
         debug: ['#8e2de2', '#4a00e0'],
-        light: '#ffffff',
-        dim: '#888888'
+        text: '#ffffff',
+        dim: '#888888',
+        accent: '#00b09b'
     },
+    // 2. Neon (Bright, cyber)
     neon: {
-        success: ['#39FF14', '#00FF00'],
-        error: ['#FF00FF', '#FF0099'],
-        warning: ['#FFFF00', '#FFD700'],
-        info: ['#00FFFF', '#00BFFF'],
-        debug: ['#9D00FF', '#7F00FF'],
-        light: '#ffffff',
-        dim: '#444444'
+        success: ['#39ff14', '#00ffef'],
+        error: ['#ff0055', '#ff0099'],
+        warning: ['#ffff00', '#ffae00'],
+        info: ['#00ffff', '#0099ff'],
+        debug: ['#b300ff', '#8800ff'],
+        text: '#f0f0f0',
+        dim: '#666666',
+        accent: '#39ff14'
     },
-    pastel: {
-        success: ['#77DD77', '#55BB55'],
-        error: ['#FF6961', '#FF4444'],
-        warning: ['#FFB347', '#FF9933'],
-        info: ['#AEC6CF', '#88aabb'],
-        debug: ['#B39EB5', '#9988aa'],
-        light: '#ffffff',
-        dim: '#999999'
+    // 3. Cyberpunk 2077
+    cyberpunk: {
+        success: ['#00ff9f', '#00b8ff'], // Cyan to Blue
+        error: ['#ff003c', '#ff3cac'],   // Cyber Red
+        warning: ['#fcee0a', '#ffae00'], // Cyber Yellow
+        info: ['#0abdc6', '#ea00d9'],    // Blue to Pink
+        debug: ['#711c91', '#ea00d9'],   // Purple
+        text: '#fcee0a',                 // Yellow text
+        dim: '#5e4e69',
+        accent: '#0abdc6'
     },
-    hacker: {
-        success: ['#0f0', '#00ff00'],
-        error: ['#f00', '#ff0000'],
-        warning: ['#ff0', '#ffff00'],
-        info: ['#00f', '#0000ff'],
-        debug: ['#0ff', '#00ffff'],
-        light: '#ccffcc',
-        dim: '#003300'
+    // 4. Dracula (Dark mode favorite)
+    dracula: {
+        success: ['#50fa7b', '#8be9fd'],
+        error: ['#ff5555', '#ffb86c'],
+        warning: ['#ffb86c', '#f1fa8c'],
+        info: ['#bd93f9', '#ff79c6'],
+        debug: ['#6272a4', '#8be9fd'],
+        text: '#f8f8f2',
+        dim: '#6272a4',
+        accent: '#bd93f9'
+    },
+    // 5. Monokai
+    monokai: {
+        success: ['#a6e22e', '#a6e22e'],
+        error: ['#f92672', '#f92672'],
+        warning: ['#fd971f', '#e6db74'],
+        info: ['#66d9ef', '#ae81ff'],
+        debug: ['#ae81ff', '#fd971f'],
+        text: '#f8f8f2',
+        dim: '#75715e',
+        accent: '#a6e22e'
     },
+    // 6. Vaporwave
+    vaporwave: {
+        success: ['#00f0ff', '#ff00aa'],
+        error: ['#ff2a00', '#ff0066'],
+        warning: ['#ffcc00', '#ff9900'],
+        info: ['#ff77ff', '#9933ff'],
+        debug: ['#9900ff', '#5500aa'],
+        text: '#ff99ff',
+        dim: '#554477',
+        accent: '#00f0ff'
+    },
+    // 7. Midnight (Deep blues)
+    midnight: {
+        success: ['#34e89e', '#0f3443'],
+        error: ['#cb2d3e', '#ef473a'],
+        warning: ['#ffc371', '#ff5f6d'],
+        info: ['#56ccf2', '#2f80ed'],
+        debug: ['#642b73', '#c6426e'],
+        text: '#d1d1d1',
+        dim: '#4b5563',
+        accent: '#56ccf2'
+    },
+    // 8. Sunset (Warm)
     sunset: {
         success: ['#11998e', '#38ef7d'],
-        error: ['#cb2d3e', '#ef473a'],
-        warning: ['#fc4a1a', '#f7b733'],
-        info: ['#36D1DC', '#5B86E5'],
-        debug: ['#8E2DE2', '#4A00E0'],
-        light: '#fff5f5',
-        dim: '#553333'
+        error: ['#ee0979', '#ff6a00'],
+        warning: ['#ff9966', '#ff5e62'],
+        info: ['#00c6ff', '#0072ff'],
+        debug: ['#8360c3', '#2ebf91'],
+        text: '#ffedd5',
+        dim: '#7c2d12',
+        accent: '#ff9966'
     },
+    // 9. Ocean (Blues/Greens)
     ocean: {
-        success: ['#48c6ef', '#6f86d6'],
-        error: ['#fe8c00', '#f83600'],
+        success: ['#4cb8c4', '#3cd3ad'],
+        error: ['#ff416c', '#ff4b2b'],
         warning: ['#f09819', '#edde5d'],
-        info: ['#00c6ff', '#0072ff'],
+        info: ['#2b5876', '#4e4376'],
         debug: ['#1c92d2', '#f2fcfe'],
-        light: '#f0f8ff',
-        dim: '#334455'
+        text: '#e0f2fe',
+        dim: '#1e3a8a',
+        accent: '#4cb8c4'
+    },
+    // 10. Pastel (Soft)
+    pastel: {
+        success: ['#B2F7EF', '#7BDFF2'],
+        error: ['#FFB7B2', '#FF9AA2'],
+        warning: ['#FFE29A', '#FFDAC1'],
+        info: ['#A0E7E5', '#B4F8C8'],
+        debug: ['#FBE7C6', '#C3B1E1'],
+        text: '#ffffff',
+        dim: '#a0a0a0',
+        accent: '#B2F7EF'
+    },
+    // 11. Hacker
+    hacker: {
+        success: ['#00ff00', '#003300'],
+        error: ['#ff0000', '#330000'],
+        warning: ['#ffff00', '#333300'],
+        info: ['#0000ff', '#000033'],
+        debug: ['#ff00ff', '#330033'],
+        text: '#00ff00',
+        dim: '#004400',
+        accent: '#00ff00'
+    },
+    // 12. Volcano
+    volcano: {
+        success: ['#FF8008', '#FFC837'],
+        error: ['#FF0000', '#950000'],
+        warning: ['#FF4B1F', '#1FDDFF'],
+        info: ['#ED4264', '#FFEDBC'],
+        debug: ['#2C3E50', '#FD746C'],
+        text: '#FFD700',
+        dim: '#500000',
+        accent: '#FF4B1F'
+    },
+    // 13. Forest
+    forest: {
+        success: ['#134E5E', '#71B280'],
+        error: ['#603813', '#b29f94'],
+        warning: ['#eacda3', '#d6ae7b'],
+        info: ['#5D4157', '#A8CABA'],
+        debug: ['#4DA0B0', '#D39D38'],
+        text: '#D4FFD6',
+        dim: '#2b3d2b',
+        accent: '#71B280'
+    },
+    // 14. Gold (Luxury)
+    gold: {
+        success: ['#F2994A', '#F2C94C'],
+        error: ['#8e2de2', '#4a00e0'],
+        warning: ['#CAC531', '#F3F9A7'],
+        info: ['#7F7FD5', '#86A8E7'],
+        debug: ['#E0EAFC', '#CFDEF3'],
+        text: '#FFD700',
+        dim: '#706015',
+        accent: '#F2C94C'
     }
 };
 
-export type ThemeName = keyof typeof palettes;
+export class PaletteEngine {
+    private currentTheme: ThemeName = 'zen';
+    private theme: Theme = palettes.zen;
+
+    setTheme(name: ThemeName) {
+        if (palettes[name]) {
+            this.currentTheme = name;
+            this.theme = palettes[name];
+        }
+    }
+
+    get colors() {
+        return this.theme;
+    }
+
+    apply(text: string, colors: string[]): string {
+        if (colors.length === 1) return KaiChroma.hex(colors[0], text);
+        return KaiChroma.gradient(colors, text);
+    }
+}
+
+export const paint = new PaletteEngine();

package/src/transports/ConsoleTransport.ts

@@ -1,6 +1,6 @@
-import chalk from 'chalk';
+
 import { LogLevel, Transport } from '../types';
-import { paint } from '../styles/gradients';
+import { paint } from '../styles/palettes';
 import { palettes, ThemeName } from '../styles/palettes';
 
 export class ConsoleTransport implements Transport {

package/src/utils/json.ts

@@ -1,23 +1,31 @@
-import chalk from 'chalk';
+
+import { KaiChroma } from '../styles/KaiChroma';
 
 export class KaiJson {
     static print(obj: any, theme: any) {
         const jsonStr = JSON.stringify(obj, null, 2);
+        
+        // Manual colorization for full control using KaiChroma
         const colored = jsonStr
+            // Strings (keys)
             .replace(/"([^"]+)":/g, (match, key) => {
-                return chalk.hex(theme.info[0])(`"${key}"`) + ':';
+                return KaiChroma.hex(theme.info[0], `"${key}"`) + ':';
             })
+            // String values
             .replace(/: "([^"]*)"/g, (match, val) => {
-                return ': ' + chalk.hex(theme.success[1])(`"${val}"`);
+                return ': ' + KaiChroma.hex(theme.success[1], `"${val}"`);
             })
+            // Numbers
             .replace(/: (\d+\.?\d*)/g, (match, num) => {
-                return ': ' + chalk.hex(theme.warning[0])(num);
+                return ': ' + KaiChroma.hex(theme.warning[0], num);
             })
+            // Booleans
             .replace(/: (true|false)/g, (match, bool) => {
-                return ': ' + chalk.hex(theme.error[0])(bool);
+                return ': ' + KaiChroma.hex(theme.error[0], bool);
             })
+            // Null
             .replace(/: (null)/g, (match, n) => {
-                return ': ' + chalk.hex(theme.dim)(n);
+                return ': ' + KaiChroma.hex(theme.dim, n);
             });
 
         console.log(colored);