hanzio 1.0.0 → 1.0.3

package/README.md

@@ -2,7 +2,7 @@
 
 A small TypeScript-first utility library for common application code: arrays,
 strings, promises, caching, state machines, dates, URLs, Zod helpers, API clients,
-JWTs, gzip, sitemap crawling, and queues.
+JWTs, gzip, sitemap crawling, queues, and colorful terminal logging.
 
 ## Install
 
@@ -30,6 +30,7 @@ import { jwtSign } from 'hanzio/jwt'
 import { compressString } from 'hanzio/gzip'
 import { getDomainSitemap } from 'hanzio/sitemap'
 import PQueue from 'hanzio/p-queue'
+import { createCoolLogger } from 'hanzio/cool-console-log'
 ```
 
 The package currently publishes `src/**/*.ts` intentionally so Bun can consume
@@ -500,6 +501,34 @@ try {
 }
 ```
 
+### Cool console log
+
+ANSI-colored logging for terminals. Exports include `terminalColors`, `createCoolLogger`,
+`logOperationSummary`, `colorize`, and `logBanner`. By default colors and banners are
+development-only (`NODE_ENV !== 'production'`); loggers honor `colorsInDevOnly`
+and callbacks via `CoolLoggerOptions.onLog`.
+
+```ts
+import {
+	createCoolLogger,
+	colorize,
+	logBanner,
+	logOperationSummary,
+	terminalColors
+} from 'hanzio'
+
+const log = createCoolLogger()
+log.info('User logged in', { userId: '123' })
+log.warn('Rate limit approaching', { remaining: 10 })
+
+const start = performance.now()
+await doSomething()
+logOperationSummary('user.create', performance.now() - start, true)
+
+console.log(colorize('OK', 'brightGreen'))
+logBanner('Server started', 'cyan')
+```
+
 ## Development
 
 ```bash

package/dist/cool-console-log/index.d.ts

@@ -0,0 +1,108 @@
+/** ANSI color codes for terminal output */
+export declare const terminalColors: {
+    readonly reset: "\u001B[0m";
+    readonly bold: "\u001B[1m";
+    readonly dim: "\u001B[2m";
+    readonly italic: "\u001B[3m";
+    readonly underline: "\u001B[4m";
+    readonly black: "\u001B[30m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly magenta: "\u001B[35m";
+    readonly cyan: "\u001B[36m";
+    readonly white: "\u001B[37m";
+    readonly gray: "\u001B[90m";
+    readonly brightRed: "\u001B[91m";
+    readonly brightGreen: "\u001B[92m";
+    readonly brightYellow: "\u001B[93m";
+    readonly brightBlue: "\u001B[94m";
+    readonly brightMagenta: "\u001B[95m";
+    readonly brightCyan: "\u001B[96m";
+    readonly brightWhite: "\u001B[97m";
+    readonly bgBlack: "\u001B[40m";
+    readonly bgRed: "\u001B[41m";
+    readonly bgGreen: "\u001B[42m";
+    readonly bgYellow: "\u001B[43m";
+    readonly bgBlue: "\u001B[44m";
+    readonly bgMagenta: "\u001B[45m";
+    readonly bgCyan: "\u001B[46m";
+    readonly bgWhite: "\u001B[47m";
+};
+export type TerminalColor = keyof typeof terminalColors;
+/** Log levels supported by the logger */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/** Attributes that can be passed to log methods */
+export type LogAttributes = Record<string, string | number | boolean>;
+/** Log method signature */
+export type LogMethod = (message: string, attributes?: LogAttributes) => void;
+/** Logger interface with colored output */
+export type CoolLogger = {
+    debug: LogMethod;
+    info: LogMethod;
+    warn: LogMethod;
+    error: LogMethod;
+};
+/**
+ * Options for creating a cool logger
+ */
+export type CoolLoggerOptions = {
+    /** Only use colors in development (default: true) */
+    colorsInDevOnly?: boolean;
+    /** Callback for each log entry (e.g., to add to OpenTelemetry span) */
+    onLog?: (level: LogLevel, message: string, attributes?: LogAttributes) => void;
+};
+/**
+ * Creates a logger with colorful console output.
+ *
+ * @example
+ * ```ts
+ * const logger = createCoolLogger()
+ * logger.info('User logged in', { userId: '123' })
+ * logger.warn('Rate limit approaching', { remaining: 10 })
+ * logger.error('Payment failed', { reason: 'insufficient_funds' })
+ * ```
+ */
+export declare function createCoolLogger(options?: CoolLoggerOptions): CoolLogger;
+/**
+ * Logs a request/operation summary with colored status and duration.
+ * Shows: `operationName ✓ · 12.3ms` (green) or `operationName ✗ · 45.2ms` (red)
+ *
+ * @example
+ * ```ts
+ * const start = performance.now()
+ * try {
+ *   await doSomething()
+ *   logOperationSummary('user.create', performance.now() - start, true)
+ * } catch {
+ *   logOperationSummary('user.create', performance.now() - start, false)
+ * }
+ * ```
+ */
+export declare function logOperationSummary(operationName: string, durationMs: number, success: boolean, options?: {
+    devOnly?: boolean;
+    error?: Error | unknown;
+}): void;
+/**
+ * Helper to colorize text for console output
+ *
+ * @example
+ * ```ts
+ * console.log(colorize('Success!', 'green', 'bold'))
+ * console.log(colorize('Warning', 'yellow'))
+ * ```
+ */
+export declare function colorize(text: string, color: TerminalColor, ...modifiers: TerminalColor[]): string;
+/**
+ * Log a styled box/banner to the console (dev only)
+ *
+ * @example
+ * ```ts
+ * logBanner('Server Started', 'green')
+ * logBanner('⚠️  Warning', 'yellow')
+ * ```
+ */
+export declare function logBanner(text: string, color?: TerminalColor, options?: {
+    devOnly?: boolean;
+}): void;

package/dist/cool-console-log/index.js

@@ -0,0 +1,111 @@
+// src/cool-console-log/index.ts
+var terminalColors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m",
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightBlue: "\x1B[94m",
+  brightMagenta: "\x1B[95m",
+  brightCyan: "\x1B[96m",
+  brightWhite: "\x1B[97m",
+  bgBlack: "\x1B[40m",
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgYellow: "\x1B[43m",
+  bgBlue: "\x1B[44m",
+  bgMagenta: "\x1B[45m",
+  bgCyan: "\x1B[46m",
+  bgWhite: "\x1B[47m"
+};
+var levelColors = {
+  debug: { badge: terminalColors.gray, text: terminalColors.dim },
+  info: { badge: terminalColors.cyan, text: terminalColors.reset },
+  warn: { badge: terminalColors.yellow, text: terminalColors.yellow },
+  error: { badge: terminalColors.red, text: terminalColors.brightRed }
+};
+function formatAttributes(attrs) {
+  if (!attrs || Object.keys(attrs).length === 0)
+    return "";
+  const formatted = Object.entries(attrs).map(([k, v]) => `${terminalColors.dim}${k}=${terminalColors.reset}${v}`).join(" ");
+  return ` ${formatted}`;
+}
+function createCoolLogger(options = {}) {
+  const { colorsInDevOnly = true, onLog } = options;
+  const isDev = true;
+  const useColors = colorsInDevOnly ? isDev : true;
+  const createLogMethod = (level) => (message, attributes) => {
+    onLog?.(level, message, attributes);
+    if (level === "debug" && !isDev)
+      return;
+    if (useColors) {
+      const { badge, text } = levelColors[level];
+      const label = level.toUpperCase().padEnd(5);
+      const attrStr = formatAttributes(attributes);
+      console.log(`${badge}[${label}]${terminalColors.reset} ${text}${message}${terminalColors.reset}${attrStr}`);
+    } else {
+      console[level](`[${level.toUpperCase()}]`, message, attributes ?? "");
+    }
+  };
+  return {
+    debug: createLogMethod("debug"),
+    info: createLogMethod("info"),
+    warn: createLogMethod("warn"),
+    error: createLogMethod("error")
+  };
+}
+function logOperationSummary(operationName, durationMs, success, options = {}) {
+  const { devOnly = true, error } = options;
+  const isDev = true;
+  if (devOnly && !isDev)
+    return;
+  const c = terminalColors;
+  const statusIcon = success ? `${c.brightGreen}✓${c.reset}` : `${c.brightRed}✗${c.reset}`;
+  const statusColor = success ? c.green : c.red;
+  const durationStr = `${c.dim}${durationMs.toFixed(1)}ms${c.reset}`;
+  const errorMessage = error ? ` ${c.dim}·${c.reset} ${c.red}${error instanceof Error ? error.message : String(error)}${c.reset}` : "";
+  console.log(`${statusColor}${c.bold}${operationName}${c.reset} ${statusIcon} ${c.dim}·${c.reset} ${durationStr}${errorMessage}`);
+}
+function colorize(text, color, ...modifiers) {
+  const isDev = true;
+  if (!isDev)
+    return text;
+  const colorCodes = [
+    terminalColors[color],
+    ...modifiers.map((m) => terminalColors[m])
+  ].join("");
+  return `${colorCodes}${text}${terminalColors.reset}`;
+}
+function logBanner(text, color = "cyan", options = {}) {
+  const { devOnly = true } = options;
+  const isDev = true;
+  if (devOnly && !isDev) {
+    console.log(`=== ${text} ===`);
+    return;
+  }
+  const c = terminalColors;
+  const padding = 2;
+  const line = "═".repeat(text.length + padding * 2);
+  console.log(`${c[color]}╔${line}╗${c.reset}`);
+  console.log(`${c[color]}║${" ".repeat(padding)}${c.bold}${text}${c.reset}${c[color]}${" ".repeat(padding)}║${c.reset}`);
+  console.log(`${c[color]}╚${line}╝${c.reset}`);
+}
+export {
+  terminalColors,
+  logOperationSummary,
+  logBanner,
+  createCoolLogger,
+  colorize
+};

package/dist/index.d.ts

@@ -10,3 +10,7 @@ export * from './url';
 export * from './zod';
 export * from './api-wrapper';
 export * from './p-queue';
+export * from './cool-console-log';
+export * from './jwt';
+export * from './gzip';
+export * from './sitemap';

package/dist/index.js

@@ -879,6 +879,150 @@ class PQueue {
   }
 }
 
+// src/jwt/index.ts
+import * as jose from "jose";
+async function jwtSign(payload, secret) {
+  const secretKey = new TextEncoder().encode(secret);
+  return await new jose.SignJWT(payload).setProtectedHeader({ alg: "HS256" }).setIssuedAt().sign(secretKey);
+}
+async function jwtVerify2(token, secret) {
+  try {
+    const secretKey = new TextEncoder().encode(secret);
+    const { payload } = await jose.jwtVerify(token, secretKey);
+    return payload;
+  } catch (_error) {
+    return null;
+  }
+}
+
+// src/gzip/index.ts
+import pako from "pako";
+function compressString(input) {
+  const uint8Array = new TextEncoder().encode(input);
+  const compressed = pako.deflate(uint8Array);
+  return btoa(String.fromCharCode.apply(null, compressed));
+}
+function decompressString(compressedString) {
+  const compressedData = new Uint8Array(atob(compressedString).split("").map((char) => char.charCodeAt(0)));
+  const decompressed = pako.inflate(compressedData);
+  return new TextDecoder().decode(decompressed);
+}
+
+// src/sitemap/index.ts
+var createTimeoutController = (timeout) => {
+  const controller = new AbortController;
+  setTimeout(() => controller.abort(), timeout);
+  return controller;
+};
+var discoverSitemaps = async (domain) => {
+  const normalizedDomain = domain.replace(/\/$/, "");
+  const commonLocations = [
+    "/sitemap.xml",
+    "/sitemap_index.xml",
+    "/sitemap/",
+    "/sitemaps.xml",
+    "/sitemap/sitemap.xml"
+  ];
+  const sitemaps = new Set;
+  const requestOptions = {
+    headers: {
+      "User-Agent": "SitemapCrawler/1.0"
+    },
+    signal: createTimeoutController(5000).signal
+  };
+  try {
+    const robotsTxt = await fetch(`${normalizedDomain}/robots.txt`, {
+      ...requestOptions
+    });
+    if (robotsTxt.ok) {
+      const text = await robotsTxt.text();
+      const sitemapMatches = text.match(/Sitemap: (.*)/gi);
+      if (sitemapMatches) {
+        sitemapMatches.forEach((match) => {
+          const url = match.replace("Sitemap:", "").trim();
+          sitemaps.add(url);
+        });
+      }
+      if (sitemaps.size > 0) {
+        return [...sitemaps];
+      }
+    }
+  } catch (error) {
+    console.warn("Could not fetch robots.txt:", error instanceof Error ? error.message : "Unknown error");
+  }
+  for (const location of commonLocations) {
+    try {
+      const response = await fetch(`${normalizedDomain}${location}`, {
+        ...requestOptions,
+        method: "HEAD"
+      });
+      if (response.ok) {
+        return [`${normalizedDomain}${location}`];
+      }
+    } catch (_error) {}
+  }
+  return [];
+};
+var getDomainSitemap = async (domain, options = {}) => {
+  const {
+    filterIndexes,
+    concurrency = 10,
+    maxDepth = 5,
+    timeout = 1e4
+  } = options;
+  let normalizedDomain = domain.replace(/\/$/, "");
+  if (!normalizedDomain.startsWith("http")) {
+    normalizedDomain = `https://${normalizedDomain}`;
+  }
+  const sitemapUrls = await discoverSitemaps(normalizedDomain);
+  if (sitemapUrls.length === 0) {
+    throw new Error("No sitemaps found for the domain");
+  }
+  const queue = new PQueue({ concurrency });
+  const result = {
+    links: new Set,
+    visited: new Set
+  };
+  const locRegex = /<loc>([^<]+)<\/loc>/g;
+  const isXmlSitemap = (url) => url.endsWith(".xml") || url.toLowerCase().includes("sitemap");
+  const processSitemap = async (sitemapUrl, depth = 0) => {
+    if (depth > maxDepth || result.visited.has(sitemapUrl)) {
+      return;
+    }
+    result.visited.add(sitemapUrl);
+    try {
+      const controller = createTimeoutController(timeout);
+      const response = await fetch(sitemapUrl, {
+        headers: {
+          "User-Agent": "SitemapCrawler/1.0"
+        },
+        signal: controller.signal
+      });
+      if (!response.ok)
+        throw new Error(`HTTP error! status: ${response.status}`);
+      const data = await response.text();
+      const matches = [...data.matchAll(locRegex)].map((match) => match[1].trim()).filter((link) => {
+        if (filterIndexes && isXmlSitemap(link)) {
+          return link.includes(filterIndexes);
+        }
+        return true;
+      });
+      for (const link of matches) {
+        if (isXmlSitemap(link)) {
+          queue.add(() => processSitemap(link, depth + 1));
+        } else {
+          result.links.add(link);
+        }
+      }
+    } catch (error) {
+      console.warn(`Failed to process sitemap ${sitemapUrl}:`, error instanceof Error ? error.message : "Unknown error");
+    }
+  };
+  await Promise.all(sitemapUrls.map((sitemapUrl) => queue.add(() => processSitemap(sitemapUrl))));
+  await queue.onIdle();
+  return [...result.links];
+};
+
 // src/typedswitch/index.ts
 function runSwitch(value, keyOrCases, casesOrDefault, defaultCase) {
   let key;
@@ -1514,6 +1658,110 @@ function formatPeriodLabel(start, end, includeDay = false) {
 function getDomainFaviconUrl(domain, size = 128) {
   return `https://www.google.com/s2/favicons?domain=${encodeURIComponent(domain)}&sz=${size}`;
 }
+// src/cool-console-log/index.ts
+var terminalColors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m",
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightBlue: "\x1B[94m",
+  brightMagenta: "\x1B[95m",
+  brightCyan: "\x1B[96m",
+  brightWhite: "\x1B[97m",
+  bgBlack: "\x1B[40m",
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgYellow: "\x1B[43m",
+  bgBlue: "\x1B[44m",
+  bgMagenta: "\x1B[45m",
+  bgCyan: "\x1B[46m",
+  bgWhite: "\x1B[47m"
+};
+var levelColors = {
+  debug: { badge: terminalColors.gray, text: terminalColors.dim },
+  info: { badge: terminalColors.cyan, text: terminalColors.reset },
+  warn: { badge: terminalColors.yellow, text: terminalColors.yellow },
+  error: { badge: terminalColors.red, text: terminalColors.brightRed }
+};
+function formatAttributes(attrs) {
+  if (!attrs || Object.keys(attrs).length === 0)
+    return "";
+  const formatted = Object.entries(attrs).map(([k, v]) => `${terminalColors.dim}${k}=${terminalColors.reset}${v}`).join(" ");
+  return ` ${formatted}`;
+}
+function createCoolLogger(options = {}) {
+  const { colorsInDevOnly = true, onLog } = options;
+  const isDev = true;
+  const useColors = colorsInDevOnly ? isDev : true;
+  const createLogMethod = (level) => (message, attributes) => {
+    onLog?.(level, message, attributes);
+    if (level === "debug" && !isDev)
+      return;
+    if (useColors) {
+      const { badge, text } = levelColors[level];
+      const label = level.toUpperCase().padEnd(5);
+      const attrStr = formatAttributes(attributes);
+      console.log(`${badge}[${label}]${terminalColors.reset} ${text}${message}${terminalColors.reset}${attrStr}`);
+    } else {
+      console[level](`[${level.toUpperCase()}]`, message, attributes ?? "");
+    }
+  };
+  return {
+    debug: createLogMethod("debug"),
+    info: createLogMethod("info"),
+    warn: createLogMethod("warn"),
+    error: createLogMethod("error")
+  };
+}
+function logOperationSummary(operationName, durationMs, success, options = {}) {
+  const { devOnly = true, error } = options;
+  const isDev = true;
+  if (devOnly && !isDev)
+    return;
+  const c = terminalColors;
+  const statusIcon = success ? `${c.brightGreen}✓${c.reset}` : `${c.brightRed}✗${c.reset}`;
+  const statusColor = success ? c.green : c.red;
+  const durationStr = `${c.dim}${durationMs.toFixed(1)}ms${c.reset}`;
+  const errorMessage = error ? ` ${c.dim}·${c.reset} ${c.red}${error instanceof Error ? error.message : String(error)}${c.reset}` : "";
+  console.log(`${statusColor}${c.bold}${operationName}${c.reset} ${statusIcon} ${c.dim}·${c.reset} ${durationStr}${errorMessage}`);
+}
+function colorize(text, color, ...modifiers) {
+  const isDev = true;
+  if (!isDev)
+    return text;
+  const colorCodes = [
+    terminalColors[color],
+    ...modifiers.map((m) => terminalColors[m])
+  ].join("");
+  return `${colorCodes}${text}${terminalColors.reset}`;
+}
+function logBanner(text, color = "cyan", options = {}) {
+  const { devOnly = true } = options;
+  const isDev = true;
+  if (devOnly && !isDev) {
+    console.log(`=== ${text} ===`);
+    return;
+  }
+  const c = terminalColors;
+  const padding = 2;
+  const line = "═".repeat(text.length + padding * 2);
+  console.log(`${c[color]}╔${line}╗${c.reset}`);
+  console.log(`${c[color]}║${" ".repeat(padding)}${c.bold}${text}${c.reset}${c[color]}${" ".repeat(padding)}║${c.reset}`);
+  console.log(`${c[color]}╚${line}╝${c.reset}`);
+}
 export {
   zodToTypeString,
   zodToExample,
@@ -1524,6 +1772,7 @@ export {
   typedSwitch,
   tryCatch,
   toGteLteFilter,
+  terminalColors,
   slugify,
   seriesColorKey,
   resolveSeriesColorMap,
@@ -1531,8 +1780,12 @@ export {
   pickItemsInArray,
   partition,
   normalizeSingleOrArray,
+  logOperationSummary,
+  logBanner,
   linearRegressionTrend,
   keyBy,
+  jwtVerify2 as jwtVerify,
+  jwtSign,
   jsonToZodSchemaMapper,
   isSuccess,
   isFailure,
@@ -1542,16 +1795,21 @@ export {
   getUniqueValues,
   getPreviousReportPeriod,
   getHeatmapCellStyle,
+  getDomainSitemap,
   getDomainFaviconUrl,
   generateId,
   formatPeriodLabel,
   findArrayDifferenceByKey,
   extractNumber,
+  decompressString,
   createZId,
   createResolveColorsByKeys,
+  createCoolLogger,
   createApiWrapper,
   createApiClient,
+  compressString,
   compact,
+  colorize,
   chunkArray,
   cacheFunction,
   backgroundPromiseSync,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hanzio",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "A set of utility functions for TypeScript",
   "type": "module",
   "module": "./dist/index.js",
@@ -34,42 +34,6 @@
       "bun": "./src/index.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
-    },
-    "./zod": {
-      "types": "./dist/zod/index.d.ts",
-      "bun": "./src/zod/index.ts",
-      "import": "./dist/zod/index.js",
-      "default": "./dist/zod/index.js"
-    },
-    "./api-wrapper": {
-      "types": "./dist/api-wrapper/index.d.ts",
-      "bun": "./src/api-wrapper/index.ts",
-      "import": "./dist/api-wrapper/index.js",
-      "default": "./dist/api-wrapper/index.js"
-    },
-    "./jwt": {
-      "types": "./dist/jwt/index.d.ts",
-      "bun": "./src/jwt/index.ts",
-      "import": "./dist/jwt/index.js",
-      "default": "./dist/jwt/index.js"
-    },
-    "./gzip": {
-      "types": "./dist/gzip/index.d.ts",
-      "bun": "./src/gzip/index.ts",
-      "import": "./dist/gzip/index.js",
-      "default": "./dist/gzip/index.js"
-    },
-    "./sitemap": {
-      "types": "./dist/sitemap/index.d.ts",
-      "bun": "./src/sitemap/index.ts",
-      "import": "./dist/sitemap/index.js",
-      "default": "./dist/sitemap/index.js"
-    },
-    "./p-queue": {
-      "types": "./dist/p-queue/index.d.ts",
-      "bun": "./src/p-queue/index.ts",
-      "import": "./dist/p-queue/index.js",
-      "default": "./dist/p-queue/index.js"
     }
   },
   "scripts": {

package/src/cool-console-log/index.ts

@@ -0,0 +1,229 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// Cool Console Log - Colorful Terminal Logging Utility
+// ═══════════════════════════════════════════════════════════════════════════
+
+/** ANSI color codes for terminal output */
+export const terminalColors = {
+	reset: '\x1b[0m',
+	bold: '\x1b[1m',
+	dim: '\x1b[2m',
+	italic: '\x1b[3m',
+	underline: '\x1b[4m',
+	// Foreground colors
+	black: '\x1b[30m',
+	red: '\x1b[31m',
+	green: '\x1b[32m',
+	yellow: '\x1b[33m',
+	blue: '\x1b[34m',
+	magenta: '\x1b[35m',
+	cyan: '\x1b[36m',
+	white: '\x1b[37m',
+	gray: '\x1b[90m',
+	// Bright variants
+	brightRed: '\x1b[91m',
+	brightGreen: '\x1b[92m',
+	brightYellow: '\x1b[93m',
+	brightBlue: '\x1b[94m',
+	brightMagenta: '\x1b[95m',
+	brightCyan: '\x1b[96m',
+	brightWhite: '\x1b[97m',
+	// Background colors
+	bgBlack: '\x1b[40m',
+	bgRed: '\x1b[41m',
+	bgGreen: '\x1b[42m',
+	bgYellow: '\x1b[43m',
+	bgBlue: '\x1b[44m',
+	bgMagenta: '\x1b[45m',
+	bgCyan: '\x1b[46m',
+	bgWhite: '\x1b[47m'
+} as const
+
+export type TerminalColor = keyof typeof terminalColors
+
+/** Log levels supported by the logger */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+/** Attributes that can be passed to log methods */
+export type LogAttributes = Record<string, string | number | boolean>
+
+/** Log method signature */
+export type LogMethod = (message: string, attributes?: LogAttributes) => void
+
+/** Logger interface with colored output */
+export type CoolLogger = {
+	debug: LogMethod
+	info: LogMethod
+	warn: LogMethod
+	error: LogMethod
+}
+
+/** Color config per log level */
+const levelColors: Record<LogLevel, { badge: string; text: string }> = {
+	debug: { badge: terminalColors.gray, text: terminalColors.dim },
+	info: { badge: terminalColors.cyan, text: terminalColors.reset },
+	warn: { badge: terminalColors.yellow, text: terminalColors.yellow },
+	error: { badge: terminalColors.red, text: terminalColors.brightRed }
+}
+
+/** Format attributes as a compact colored string */
+function formatAttributes(attrs?: LogAttributes): string {
+	if (!attrs || Object.keys(attrs).length === 0) return ''
+	const formatted = Object.entries(attrs)
+		.map(([k, v]) => `${terminalColors.dim}${k}=${terminalColors.reset}${v}`)
+		.join(' ')
+	return ` ${formatted}`
+}
+
+/**
+ * Options for creating a cool logger
+ */
+export type CoolLoggerOptions = {
+	/** Only use colors in development (default: true) */
+	colorsInDevOnly?: boolean
+	/** Callback for each log entry (e.g., to add to OpenTelemetry span) */
+	onLog?: (level: LogLevel, message: string, attributes?: LogAttributes) => void
+}
+
+/**
+ * Creates a logger with colorful console output.
+ *
+ * @example
+ * ```ts
+ * const logger = createCoolLogger()
+ * logger.info('User logged in', { userId: '123' })
+ * logger.warn('Rate limit approaching', { remaining: 10 })
+ * logger.error('Payment failed', { reason: 'insufficient_funds' })
+ * ```
+ */
+export function createCoolLogger(options: CoolLoggerOptions = {}): CoolLogger {
+	const { colorsInDevOnly = true, onLog } = options
+	const isDev = process.env.NODE_ENV !== 'production'
+	const useColors = colorsInDevOnly ? isDev : true
+
+	const createLogMethod =
+		(level: LogLevel): LogMethod =>
+		(message, attributes) => {
+			// Call the onLog callback if provided
+			onLog?.(level, message, attributes)
+
+			// Skip debug logs in production
+			if (level === 'debug' && !isDev) return
+
+			if (useColors) {
+				const { badge, text } = levelColors[level]
+				const label = level.toUpperCase().padEnd(5)
+				const attrStr = formatAttributes(attributes)
+				console.log(
+					`${badge}[${label}]${terminalColors.reset} ${text}${message}${terminalColors.reset}${attrStr}`
+				)
+			} else {
+				console[level](`[${level.toUpperCase()}]`, message, attributes ?? '')
+			}
+		}
+
+	return {
+		debug: createLogMethod('debug'),
+		info: createLogMethod('info'),
+		warn: createLogMethod('warn'),
+		error: createLogMethod('error')
+	}
+}
+
+/**
+ * Logs a request/operation summary with colored status and duration.
+ * Shows: `operationName ✓ · 12.3ms` (green) or `operationName ✗ · 45.2ms` (red)
+ *
+ * @example
+ * ```ts
+ * const start = performance.now()
+ * try {
+ *   await doSomething()
+ *   logOperationSummary('user.create', performance.now() - start, true)
+ * } catch {
+ *   logOperationSummary('user.create', performance.now() - start, false)
+ * }
+ * ```
+ */
+export function logOperationSummary(
+	operationName: string,
+	durationMs: number,
+	success: boolean,
+	options: { devOnly?: boolean; error?: Error | unknown } = {}
+): void {
+	const { devOnly = true, error } = options
+	const isDev = process.env.NODE_ENV !== 'production'
+
+	if (devOnly && !isDev) return
+
+	const c = terminalColors
+	const statusIcon = success
+		? `${c.brightGreen}✓${c.reset}`
+		: `${c.brightRed}✗${c.reset}`
+	const statusColor = success ? c.green : c.red
+	const durationStr = `${c.dim}${durationMs.toFixed(1)}ms${c.reset}`
+
+	const errorMessage = error
+		? ` ${c.dim}·${c.reset} ${c.red}${error instanceof Error ? error.message : String(error)}${c.reset}`
+		: ''
+
+	console.log(
+		`${statusColor}${c.bold}${operationName}${c.reset} ${statusIcon} ${c.dim}·${c.reset} ${durationStr}${errorMessage}`
+	)
+}
+
+/**
+ * Helper to colorize text for console output
+ *
+ * @example
+ * ```ts
+ * console.log(colorize('Success!', 'green', 'bold'))
+ * console.log(colorize('Warning', 'yellow'))
+ * ```
+ */
+export function colorize(
+	text: string,
+	color: TerminalColor,
+	...modifiers: TerminalColor[]
+): string {
+	const isDev = process.env.NODE_ENV !== 'production'
+	if (!isDev) return text
+
+	const colorCodes = [
+		terminalColors[color],
+		...modifiers.map((m) => terminalColors[m])
+	].join('')
+	return `${colorCodes}${text}${terminalColors.reset}`
+}
+
+/**
+ * Log a styled box/banner to the console (dev only)
+ *
+ * @example
+ * ```ts
+ * logBanner('Server Started', 'green')
+ * logBanner('⚠️  Warning', 'yellow')
+ * ```
+ */
+export function logBanner(
+	text: string,
+	color: TerminalColor = 'cyan',
+	options: { devOnly?: boolean } = {}
+): void {
+	const { devOnly = true } = options
+	const isDev = process.env.NODE_ENV !== 'production'
+
+	if (devOnly && !isDev) {
+		console.log(`=== ${text} ===`)
+		return
+	}
+
+	const c = terminalColors
+	const padding = 2
+	const line = '═'.repeat(text.length + padding * 2)
+
+	console.log(`${c[color]}╔${line}╗${c.reset}`)
+	console.log(
+		`${c[color]}║${' '.repeat(padding)}${c.bold}${text}${c.reset}${c[color]}${' '.repeat(padding)}║${c.reset}`
+	)
+	console.log(`${c[color]}╚${line}╝${c.reset}`)
+}

package/src/index.ts

@@ -10,3 +10,7 @@ export * from './url'
 export * from './zod'
 export * from './api-wrapper'
 export * from './p-queue'
+export * from './cool-console-log'
+export * from './jwt'
+export * from './gzip'
+export * from './sitemap'