logxpert 2.0.3 → 2.1.0

package/README.md

@@ -2,6 +2,11 @@
 
 Colorful console logging for Node.js with optional daily file rotation.
 
+- Zero heavy dependencies — built-in engine.
+- Daily file rotation with retention, size limits and gzip.
+- Per-level colors, lazy messages, child loggers, isolated instances.
+- Works from JS and TS, CommonJS and ESM.
+
 ## Installation
 
 ```sh
@@ -64,9 +69,13 @@ log.settings({
     enableTimestamp: true,
     timestampFormat: 'YYYY-MM-DD HH:mm:ss',
     colorize: true,
+    colors: { info: 'blue', error: false }, // names, ANSI 0-255, or false per level
   },
 });
 
+// Default colors: error red, warn yellow, info green, http magenta,
+// verbose cyan, debug blue, silly gray. Only the [level] tag is colored.
+
 const { createLogger } = require('logxpert');
 const apiLog = createLogger({ level: 'info' }); // independent instance
 
@@ -84,6 +93,8 @@ log.settings({
     timestampPrefix: '',
     timestampSuffix: '',
     colorize: true,
+    colors: { info: 'blue', warn: 208, error: false }
+    // enabled: false, // file-only logging: silence the console
   },
   files: {
     folder: 'logs',

package/index.d.mts

@@ -14,6 +14,7 @@ export const info: typeof log.info;
 export const debug: typeof log.debug;
 
 export type LogLevel = log.LogLevel;
+export type LevelColor = log.LevelColor;
 export type ConsoleOptions = log.ConsoleOptions;
 export type FilesOptions = log.FilesOptions;
 export type RunNumberOptions = log.RunNumberOptions;

package/index.d.ts

@@ -1,12 +1,16 @@
 declare namespace log {
   export type LogLevel = 'error' | 'warn' | 'info' | 'http' | 'verbose' | 'debug' | 'silly';
 
+  export type LevelColor = string | number | false | null;
+
   export interface ConsoleOptions {
+    enabled?: boolean;
     enableTimestamp?: boolean;
     timestampFormat?: string;
     timestampPrefix?: string;
     timestampSuffix?: string;
     colorize?: boolean;
+    colors?: Partial<Record<LogLevel, LevelColor>>;
     level?: LogLevel;
   }
 
@@ -42,7 +46,7 @@ declare namespace log {
   }
 
   export interface LogSettingsOptions {
-    console?: ConsoleOptions;
+    console?: ConsoleOptions | false;
     files?: FilesOptions;
     level?: LogLevel;
   }

package/lib/files.js

@@ -0,0 +1,102 @@
+const fs = require('fs');
+const path = require('path');
+const { sanitizeAppName, isPadChar, assertFilenameSafe } = require('./sanitize');
+
+let cachedAppName = null;
+function getDefaultAppName() {
+  if (cachedAppName) return cachedAppName;
+  try {
+    const pkgPath = path.resolve(process.cwd(), 'package.json');
+    const raw = fs.readFileSync(pkgPath, 'utf8');
+    cachedAppName = sanitizeAppName(JSON.parse(raw)?.name) ?? 'application';
+  } catch {
+    cachedAppName = 'application';
+  }
+  return cachedAppName;
+}
+
+function resolveRunNumber(folder, prefix, opt) {
+  let enabled = false;
+  let separator = '-';
+  let padding = 0;
+  let startAt = 1;
+  if (opt === true) {
+    enabled = true;
+  } else if (opt && typeof opt === 'object') {
+    enabled = opt.enabled ?? true;
+    if (opt.separator !== undefined) {
+      if (typeof opt.separator !== 'string' || !opt.separator) throw new Error('files.runNumber.separator must be a non-empty string');
+      separator = opt.separator;
+    }
+    if (opt.padding !== undefined) {
+      if (!Number.isInteger(opt.padding) || opt.padding < 0) throw new Error('files.runNumber.padding must be a non-negative integer');
+      padding = opt.padding;
+    }
+    if (opt.startAt !== undefined) {
+      if (!Number.isInteger(opt.startAt) || opt.startAt < 0) throw new Error('files.runNumber.startAt must be a non-negative integer');
+      startAt = opt.startAt;
+    }
+  } else if (opt !== undefined && opt !== false) {
+    throw new Error('files.runNumber must be a boolean or an object');
+  }
+  if (!enabled) return null;
+  const counterFile = path.join(folder, `.${prefix}.run`);
+  let next = startAt;
+  try {
+    const raw = fs.readFileSync(counterFile, 'utf8').trim();
+    const prev = parseInt(raw, 10);
+    next = Number.isInteger(prev) ? prev + 1 : startAt;
+  } catch {}
+  try {
+    fs.writeFileSync(counterFile, String(next), 'utf8');
+  } catch {}
+  return separator + String(next).padStart(padding, '0');
+}
+
+function normalizeFilesOptions(files = {}) {
+  const rawFolder = files.folder ?? 'logs';
+  if (typeof rawFolder !== 'string' || !rawFolder.trim() || rawFolder.includes('\0')) {
+    throw new Error('files.folder must be a non-empty string');
+  }
+  const folder = path.normalize(rawFolder);
+  const datePattern = files.datePattern ?? files.dateFormat ?? files.filesName ?? 'YYYY_MM_DD';
+  if (typeof datePattern !== 'string' || !datePattern.trim()) {
+    throw new Error('files.datePattern must be a non-empty string');
+  }
+  const explicitPattern = files.filePattern ?? files.pattern ?? files.filename;
+  const explicitPrefix = files.prefix ?? files.appName;
+  if (explicitPattern !== undefined && explicitPrefix !== undefined) {
+    throw new Error('Do not combine "prefix" with "filePattern", pick one: prefix builds "<prefix>-%DATE%.log" for you, filePattern takes full control');
+  }
+  let filename = explicitPattern ?? `${sanitizeAppName(explicitPrefix) ?? getDefaultAppName()}-%DATE%.log`;
+  filename = filename.split('%datePattern%').join('%DATE%');
+  assertFilenameSafe(filename);
+  if (!filename.includes('%DATE%')) {
+    const ext = path.extname(filename) || '.log';
+    const base = path.basename(filename, ext);
+    filename = `${base}-%DATE%${ext}`;
+  }
+  assertFilenameSafe(filename);
+  if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
+  const rawPrefix = path.basename(filename).split('%DATE%')[0];
+  let prefixEnd = rawPrefix.length;
+  while (prefixEnd > 0 && isPadChar(rawPrefix[prefixEnd - 1])) prefixEnd--;
+  const prefix = rawPrefix.slice(0, prefixEnd) || 'application';
+  const runSuffix = resolveRunNumber(folder, sanitizeAppName(prefix) ?? 'application', files.runNumber ?? false);
+  if (runSuffix) {
+    const ext = path.extname(filename) || '.log';
+    const base = filename.slice(0, -ext.length);
+    filename = `${base}${runSuffix}${ext}`;
+  }
+  return {
+    folder,
+    datePattern,
+    filename,
+    maxFiles: files.maxFile ?? files.maxFiles ?? '14d',
+    maxSize: files.maxSize ?? '20m',
+    zippedArchive: files.zippedArchive ?? false,
+    level: files.level,
+  };
+}
+
+module.exports = { getDefaultAppName, resolveRunNumber, normalizeFilesOptions };

package/lib/format.js

@@ -0,0 +1,38 @@
+const util = require('util');
+
+function formatExtra(meta) {
+  const keys = Object.keys(meta).filter((k) => k !== 'splat' && k !== 'ms');
+  if (!keys.length) return '';
+  try {
+    const picked = {};
+    for (const k of keys) picked[k] = meta[k];
+    return JSON.stringify(picked);
+  } catch {
+    return '';
+  }
+}
+
+function mergeMeta(meta) {
+  const out = {};
+  for (const m of meta) {
+    if (m && typeof m === 'object') Object.assign(out, m);
+  }
+  return out;
+}
+
+function renderBody(message, meta) {
+  if (typeof message === 'string' && meta.length && /%[sdifoO%]/.test(message)) {
+    return util.format(message, ...meta);
+  }
+  const msg = typeof message === 'string' ? message : message == null ? '' : JSON.stringify(message);
+  const extra = formatExtra(mergeMeta(meta));
+  return [msg, extra].filter(Boolean).join(' ');
+}
+
+function buildLine(timestamp, level, message, meta, tag) {
+  const body = renderBody(message, meta);
+  const label = tag ?? `[${level}]`;
+  return timestamp ? `${timestamp} ${label}: ${body}` : `${label}: ${body}`;
+}
+
+module.exports = { formatExtra, mergeMeta, renderBody, buildLine };

package/lib/mini.js

@@ -0,0 +1,134 @@
+const LEVELS = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  verbose: 4,
+  debug: 5,
+  silly: 6,
+};
+
+const COLORS = {
+  error: 31,
+  warn: 33,
+  info: 32,
+  http: 35,
+  verbose: 36,
+  debug: 34,
+  silly: 90,
+};
+
+const NAMED_COLORS = {
+  black: 30,
+  red: 31,
+  green: 32,
+  yellow: 33,
+  blue: 34,
+  magenta: 35,
+  cyan: 36,
+  white: 37,
+  gray: 90,
+  grey: 90,
+};
+
+function resolveColorCode(value, level) {
+  if (value === undefined || value === null || value === false) return null;
+  if (typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 255) return value;
+  if (typeof value === 'string' && NAMED_COLORS[value.toLowerCase()] !== undefined) return NAMED_COLORS[value.toLowerCase()];
+  throw new Error(`Unknown color "${value}" for level "${level}". Use one of: ${Object.keys(NAMED_COLORS).join(', ')}, an ANSI code 0-255, or false to disable`);
+}
+
+function resolveLevelColors(custom = {}) {
+  if (custom === null || typeof custom !== 'object' || Array.isArray(custom)) {
+    throw new Error('console.colors must be an object mapping level names to colors');
+  }
+  const map = {};
+  for (const level of Object.keys(COLORS)) {
+    if (custom[level] !== undefined) {
+      const code = resolveColorCode(custom[level], level);
+      if (code !== null) map[level] = code;
+    } else {
+      map[level] = COLORS[level];
+    }
+  }
+  return map;
+}
+
+function colorizeLevel(level, text, colors = COLORS) {
+  const code = colors[level] ?? 0;
+  if (!code) return text;
+  return `\x1b[${code}m${text}\x1b[0m`;
+}
+
+class NullTransport {
+  constructor() {
+    this.level = 'off';
+  }
+
+  write() {}
+
+  close() {}
+}
+
+class ConsoleTransport {
+  constructor({ level, render } = {}) {
+    this.level = level;
+    this.render = render;
+  }
+
+  write(entry) {
+    const line = this.render(entry);
+    const stream = entry.level === 'error' || entry.level === 'warn' ? process.stderr : process.stdout;
+    stream.write(line + '\n');
+  }
+
+  close() {}
+}
+
+class MiniLogger {
+  constructor({ level = 'debug' } = {}) {
+    this.level = level;
+    this.levels = LEVELS;
+    this.transports = [];
+  }
+
+  add(transport) {
+    this.transports.push(transport);
+    return this;
+  }
+
+  remove(transport) {
+    const i = this.transports.indexOf(transport);
+    if (i >= 0) this.transports.splice(i, 1);
+    try {
+      transport.close?.();
+    } catch {}
+    return this;
+  }
+
+  enabled(level, transportLevel) {
+    const want = LEVELS[level];
+    const current = LEVELS[transportLevel ?? this.level];
+    return want !== undefined && current !== undefined && want <= current;
+  }
+
+  log(level, message, ...meta) {
+    for (const t of [...this.transports]) {
+      if (this.enabled(level, t.level)) t.write({ level, message, meta });
+    }
+  }
+
+  child(meta = {}) {
+    const self = this;
+    const make = (level) => (message, ...args) => self.log(level, message, meta, ...args);
+    return {
+      error: make('error'),
+      warn: make('warn'),
+      info: make('info'),
+      debug: make('debug'),
+      log: (level, message, ...args) => self.log(level, message, meta, ...args),
+    };
+  }
+}
+
+module.exports = { LEVELS, ConsoleTransport, NullTransport, MiniLogger, colorizeLevel, resolveLevelColors, NAMED_COLORS };

package/lib/rotate.js

@@ -0,0 +1,144 @@
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+const dayjs = require('dayjs');
+
+function parseSize(value, fallback) {
+  if (value == null) return fallback;
+  const m = String(value).trim().match(/^(\d+(?:\.\d+)?)\s*([kmg])?$/i);
+  if (!m) return fallback;
+  const mult = { k: 1024, m: 1024 ** 2, g: 1024 ** 3 }[(m[2] || '').toLowerCase()] ?? 1;
+  return Math.floor(parseFloat(m[1]) * mult);
+}
+
+function parseDays(value) {
+  if (value == null) return null;
+  const m = String(value).trim().match(/^(\d+)\s*d$/i);
+  return m ? parseInt(m[1], 10) : null;
+}
+
+class FileTransport {
+  constructor({ folder, filename, datePattern, maxSize = '20m', maxFiles = '14d', zippedArchive = false, level, render }) {
+    this.dirname = folder;
+    this.filename = filename;
+    this.options = { datePattern, maxSize, maxFiles, zippedArchive };
+    this.level = level;
+    this.render = render;
+    this.datePattern = datePattern;
+    this.maxBytes = parseSize(maxSize, Infinity);
+    this.maxFiles = maxFiles;
+    this.maxDays = parseDays(maxFiles);
+    this.zippedArchive = zippedArchive;
+    this.currentKey = null;
+    this.currentFile = null;
+    this.stream = null;
+    this.streamSize = 0;
+    this.streamErr = null;
+  }
+
+  fileNameFor(dateStr, n = 0) {
+    let name = this.filename.split('%DATE%').join(dateStr);
+    if (n > 0) {
+      const ext = path.extname(name) || '.log';
+      name = name.slice(0, -ext.length) + '-' + n + ext;
+    }
+    return name;
+  }
+
+  open(dateStr, startN = 0) {
+    if (!fs.existsSync(this.dirname)) fs.mkdirSync(this.dirname, { recursive: true });
+    let n = startN;
+    let full = path.join(this.dirname, this.fileNameFor(dateStr, n));
+    try {
+      let size = fs.existsSync(full) ? fs.statSync(full).size : 0;
+      while (size >= this.maxBytes && n < 1000) {
+        n += 1;
+        full = path.join(this.dirname, this.fileNameFor(dateStr, n));
+        size = fs.existsSync(full) ? fs.statSync(full).size : 0;
+      }
+    } catch {}
+    const stream = fs.createWriteStream(full, { flags: 'a' });
+    stream.on('error', (err) => { this.streamErr = err; });
+    this.stream = stream;
+    this.streamSize = 0;
+    try {
+      this.streamSize = fs.existsSync(full) ? fs.statSync(full).size : 0;
+    } catch {}
+    this.currentKey = dateStr + '#' + n;
+    this.currentFile = full;
+  }
+
+  rotateIfNeeded(dateStr, incoming) {
+    if (this.currentKey !== null && !this.currentKey.startsWith(dateStr + '#')) {
+      const previous = this.currentFile;
+      this.closeStream();
+      this.onDateChanged(previous);
+      this.currentKey = null;
+    }
+    if (this.stream === null) {
+      this.open(dateStr);
+    } else if (this.streamSize + incoming > this.maxBytes) {
+      const cur = parseInt(String(this.currentKey || '#0').split('#')[1] || '0', 10);
+      this.closeStream();
+      this.open(dateStr, cur + 1);
+    }
+  }
+
+  onDateChanged(previousFile) {
+    if (!previousFile) return;
+    try {
+      if (this.zippedArchive && fs.existsSync(previousFile)) {
+        const gz = previousFile + '.gz';
+        const data = fs.readFileSync(previousFile);
+        fs.writeFileSync(gz, zlib.gzipSync(data));
+        fs.rmSync(previousFile, { force: true });
+      }
+    } catch {}
+    this.cleanupOld();
+  }
+
+  cleanupOld() {
+    if (this.maxDays == null) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(this.dirname);
+    } catch {
+      return;
+    }
+    const cutoff = Date.now() - this.maxDays * 86400000;
+    for (const entry of entries) {
+      if (!entry.endsWith('.log') && !entry.endsWith('.log.gz') && !entry.endsWith('.gz')) continue;
+      const full = path.join(this.dirname, entry);
+      try {
+        if (fs.statSync(full).mtimeMs < cutoff) fs.rmSync(full, { force: true });
+      } catch {}
+    }
+  }
+
+  write(entry) {
+    const line = this.render(entry);
+    const buf = Buffer.byteLength(line + '\n');
+    const dateStr = dayjs().format(this.datePattern);
+    this.rotateIfNeeded(dateStr, buf);
+    if (this.stream) {
+      this.stream.write(line + '\n');
+      this.streamSize += buf;
+    }
+  }
+
+  closeStream() {
+    if (this.stream) {
+      try {
+        this.stream.end();
+      } catch {}
+      this.stream = null;
+    }
+  }
+
+  close() {
+    this.closeStream();
+    this.currentKey = null;
+  }
+}
+
+module.exports = { FileTransport, parseSize, parseDays };

package/lib/sanitize.js

@@ -0,0 +1,89 @@
+const path = require('path');
+
+const VALID_LEVELS = ['error', 'warn', 'info', 'http', 'verbose', 'debug', 'silly'];
+
+function assertLevel(level) {
+  if (!VALID_LEVELS.includes(level)) throw new Error(`Invalid log level "${level}". Use one of: ${VALID_LEVELS.join(', ')}`);
+}
+
+function stripAnsi(str) {
+  let out = '';
+  let i = 0;
+  while (i < str.length) {
+    if (str[i] !== '\x1b') {
+      out += str[i];
+      i++;
+      continue;
+    }
+    const next = str[i + 1];
+    if (next === ']') {
+      let j = i + 2;
+      while (j < str.length) {
+        if (str[j] === '\x07') { j++; break; }
+        if (str[j] === '\x1b' && str[j + 1] === '\\') { j += 2; break; }
+        j++;
+      }
+      i = j;
+    } else if (next === '[') {
+      let j = i + 2;
+      while (j < str.length && str[j] >= ' ' && str[j] <= '?') j++;
+      if (j < str.length) j++;
+      i = j;
+    } else if (next === '(' || next === ')') {
+      i += 3;
+    } else {
+      i += next === undefined ? 1 : 2;
+    }
+  }
+  return out;
+}
+const CONTROL_RE = /[\x00-\x08\x0b\x0c\x0d\x0e-\x1f\x7f]/g;
+
+function sanitizeMessage(msg) {
+  if (typeof msg !== 'string') return msg;
+  return stripAnsi(msg).replace(CONTROL_RE, '');
+}
+
+function assertFilenameSafe(filename) {
+  if (typeof filename !== 'string' || !filename.trim() || filename.includes('\0')) {
+    throw new Error('files.filename must be a non-empty string');
+  }
+  if (path.isAbsolute(filename) || filename.split(/[\\/]/).includes('..')) {
+    throw new Error('files.filename must not escape the log folder (.. and absolute paths are rejected)');
+  }
+}
+
+function isSafeChar(c) {
+  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c === '.' || c === '_' || c === '-';
+}
+
+function isPadChar(c) {
+  return c === '-' || c === '_' || c === '.';
+}
+
+function sanitizeAppName(name) {
+  if (typeof name !== 'string' || !name.trim()) return null;
+  const base = name.trim().slice(0, 200).split('/').pop();
+  let out = '';
+  for (let i = 0; i < base.length; i++) {
+    out += isSafeChar(base[i]) ? base[i] : '-';
+  }
+  let start = 0;
+  while (start < out.length && isPadChar(out[start])) start++;
+  let end = out.length;
+  while (end > start && isPadChar(out[end - 1])) end--;
+  const safe = out.slice(start, end);
+  return safe || null;
+}
+
+module.exports = {
+  VALID_LEVELS,
+  assertLevel,
+  stripAnsi,
+  CONTROL_RE,
+  sanitizeMessage,
+  assertFilenameSafe,
+  isSafeChar,
+  isPadChar,
+  sanitizeAppName,
+};

package/lib/time.js

@@ -0,0 +1,64 @@
+const dayjs = require('dayjs');
+
+const DEFAULT_CONSOLE_FORMAT = 'YYYY-MM-DD HH:mm:ss';
+
+function pad2(n) {
+  return String(n).padStart(2, '0');
+}
+
+function formatDefaultTimestamp(d = new Date()) {
+  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
+}
+
+function splitBrackets(fmt) {
+  const parts = [];
+  let current = '';
+  let i = 0;
+  while (i < fmt.length) {
+    if (fmt[i] === '[') {
+      const close = fmt.indexOf(']', i + 1);
+      if (close === -1) {
+        current += fmt.slice(i);
+        break;
+      }
+      if (current) {
+        parts.push(current);
+        current = '';
+      }
+      parts.push(fmt.slice(i, close + 1));
+      i = close + 1;
+    } else {
+      current += fmt[i];
+      i++;
+    }
+  }
+  if (current) parts.push(current);
+  return parts;
+}
+
+function compileTimestampFormatter(fmt) {
+  if (typeof fmt !== 'string' || !fmt) return formatDefaultTimestamp;
+  if (fmt === DEFAULT_CONSOLE_FORMAT) return formatDefaultTimestamp;
+  if (!fmt.includes('[') || !fmt.includes(']')) return () => dayjs().format(fmt);
+  const parts = splitBrackets(fmt).map((part) => {
+    if (part.startsWith('[') && part.endsWith(']')) {
+      const inner = part.slice(1, -1);
+      return inner ? () => '[' + dayjs().format(inner) + ']' : () => '[]';
+    }
+    return () => part;
+  });
+  return () => parts.map((f) => f()).join('');
+}
+
+function formatCustomTimestamp(fmt) {
+  return compileTimestampFormatter(fmt)();
+}
+
+module.exports = {
+  DEFAULT_CONSOLE_FORMAT,
+  pad2,
+  formatDefaultTimestamp,
+  splitBrackets,
+  compileTimestampFormatter,
+  formatCustomTimestamp,
+};

package/main.js

@@ -1,375 +1,136 @@
-const fs = require('fs');
-const path = require('path');
-const dayjs = require('dayjs');
-const { createLogger, format, transports } = require('winston');
-require('winston-daily-rotate-file');
-
-const VALID_LEVELS = ['error', 'warn', 'info', 'http', 'verbose', 'debug', 'silly'];
-const DEFAULT_CONSOLE_FORMAT = 'YYYY-MM-DD HH:mm:ss';
-
-function pad2(n) {
-  return String(n).padStart(2, '0');
-}
-
-function formatDefaultTimestamp(d = new Date()) {
-  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
-}
-
-function splitBrackets(fmt) {
-  const parts = [];
-  let current = '';
-  let i = 0;
-  while (i < fmt.length) {
-    if (fmt[i] === '[') {
-      const close = fmt.indexOf(']', i + 1);
-      if (close === -1) {
-        current += fmt.slice(i);
-        break;
-      }
-      if (current) {
-        parts.push(current);
-        current = '';
-      }
-      parts.push(fmt.slice(i, close + 1));
-      i = close + 1;
-    } else {
-      current += fmt[i];
-      i++;
-    }
-  }
-  if (current) parts.push(current);
-  return parts;
-}
-
-function compileTimestampFormatter(fmt) {
-  if (typeof fmt !== 'string' || !fmt) return formatDefaultTimestamp;
-  if (fmt === DEFAULT_CONSOLE_FORMAT) return formatDefaultTimestamp;
-  if (!fmt.includes('[') || !fmt.includes(']')) return () => dayjs().format(fmt);
-  const parts = splitBrackets(fmt).map((part) => {
-    if (part.startsWith('[') && part.endsWith(']')) {
-      const inner = part.slice(1, -1);
-      return inner ? () => '[' + dayjs().format(inner) + ']' : () => '[]';
-    }
-    return () => part;
-  });
-  return () => parts.map((f) => f()).join('');
-}
-
-function formatCustomTimestamp(fmt) {
-  return compileTimestampFormatter(fmt)();
-}
-
-function formatExtra(meta) {
-  const keys = Object.keys(meta).filter((k) => k !== 'splat' && k !== 'ms');
-  if (!keys.length) return '';
-  try {
-    const picked = {};
-    for (const k of keys) picked[k] = meta[k];
-    return JSON.stringify(picked);
-  } catch {
-    return '';
-  }
-}
-
-const prettyFormat = format.printf(({ timestamp, level, message, ...meta }) => {
-  const msg = typeof message === 'string' ? message : message == null ? '' : JSON.stringify(message);
-  const extra = formatExtra(meta);
-  const body = [msg, extra].filter(Boolean).join(' ');
-  return timestamp ? `${timestamp} [${level}]: ${body}` : `[${level}]: ${body}`;
-});
-
-function assertLevel(level) {
-  if (!VALID_LEVELS.includes(level)) throw new Error(`Invalid log level "${level}". Use one of: ${VALID_LEVELS.join(', ')}`);
-}
-
-function stripAnsi(str) {
-  let out = '';
-  let i = 0;
-  while (i < str.length) {
-    if (str[i] !== '\x1b') {
-      out += str[i];
-      i++;
-      continue;
-    }
-    const next = str[i + 1];
-    if (next === ']') {
-      let j = i + 2;
-      while (j < str.length) {
-        if (str[j] === '\x07') { j++; break; }
-        if (str[j] === '\x1b' && str[j + 1] === '\\') { j += 2; break; }
-        j++;
-      }
-      i = j;
-    } else if (next === '[') {
-      let j = i + 2;
-      while (j < str.length && str[j] >= ' ' && str[j] <= '?') j++;
-      if (j < str.length) j++;
-      i = j;
-    } else if (next === '(' || next === ')') {
-      i += 3;
-    } else {
-      i += next === undefined ? 1 : 2;
-    }
-  }
-  return out;
-}
-const CONTROL_RE = /[\x00-\x08\x0b\x0c\x0d\x0e-\x1f\x7f]/g;
-
-function sanitizeMessage(msg) {
-  if (typeof msg !== 'string') return msg;
-  return stripAnsi(msg).replace(CONTROL_RE, '');
-}
-
-function assertFilenameSafe(filename) {
-  if (typeof filename !== 'string' || !filename.trim() || filename.includes('\0')) {
-    throw new Error('files.filename must be a non-empty string');
-  }
-  if (path.isAbsolute(filename) || filename.split(/[\\/]/).includes('..')) {
-    throw new Error('files.filename must not escape the log folder (.. and absolute paths are rejected)');
-  }
-}
-
-function isSafeChar(c) {
-  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c === '.' || c === '_' || c === '-';
-}
-
-function isPadChar(c) {
-  return c === '-' || c === '_' || c === '.';
-}
-
-function sanitizeAppName(name) {
-  if (typeof name !== 'string' || !name.trim()) return null;
-  const base = name.trim().slice(0, 200).split('/').pop();
-  let out = '';
-  for (let i = 0; i < base.length; i++) {
-    out += isSafeChar(base[i]) ? base[i] : '-';
-  }
-  let start = 0;
-  while (start < out.length && isPadChar(out[start])) start++;
-  let end = out.length;
-  while (end > start && isPadChar(out[end - 1])) end--;
-  const safe = out.slice(start, end);
-  return safe || null;
-}
-
-let cachedAppName = null;
-function getDefaultAppName() {
-  if (cachedAppName) return cachedAppName;
-  try {
-    const pkgPath = path.resolve(process.cwd(), 'package.json');
-    const raw = fs.readFileSync(pkgPath, 'utf8');
-    cachedAppName = sanitizeAppName(JSON.parse(raw)?.name) ?? 'application';
-  } catch {
-    cachedAppName = 'application';
-  }
-  return cachedAppName;
-}
-
-function resolveRunNumber(folder, prefix, opt) {
-  let enabled = false;
-  let separator = '-';
-  let padding = 0;
-  let startAt = 1;
-  if (opt === true) {
-    enabled = true;
-  } else if (opt && typeof opt === 'object') {
-    enabled = opt.enabled ?? true;
-    if (opt.separator !== undefined) {
-      if (typeof opt.separator !== 'string' || !opt.separator) throw new Error('files.runNumber.separator must be a non-empty string');
-      separator = opt.separator;
-    }
-    if (opt.padding !== undefined) {
-      if (!Number.isInteger(opt.padding) || opt.padding < 0) throw new Error('files.runNumber.padding must be a non-negative integer');
-      padding = opt.padding;
-    }
-    if (opt.startAt !== undefined) {
-      if (!Number.isInteger(opt.startAt) || opt.startAt < 0) throw new Error('files.runNumber.startAt must be a non-negative integer');
-      startAt = opt.startAt;
-    }
-  } else if (opt !== undefined && opt !== false) {
-    throw new Error('files.runNumber must be a boolean or an object');
-  }
-  if (!enabled) return null;
-  const counterFile = path.join(folder, `.${prefix}.run`);
-  let next = startAt;
-  try {
-    const raw = fs.readFileSync(counterFile, 'utf8').trim();
-    const prev = parseInt(raw, 10);
-    next = Number.isInteger(prev) ? prev + 1 : startAt;
-  } catch {}
-  try {
-    fs.writeFileSync(counterFile, String(next), 'utf8');
-  } catch {}
-  return separator + String(next).padStart(padding, '0');
-}
-
-function normalizeFilesOptions(files = {}) {
-  const rawFolder = files.folder ?? 'logs';
-  if (typeof rawFolder !== 'string' || !rawFolder.trim() || rawFolder.includes('\0')) {
-    throw new Error('files.folder must be a non-empty string');
-  }
-  const folder = path.normalize(rawFolder);
-  const datePattern = files.datePattern ?? files.dateFormat ?? files.filesName ?? 'YYYY_MM_DD';
-  if (typeof datePattern !== 'string' || !datePattern.trim()) {
-    throw new Error('files.datePattern must be a non-empty string');
-  }
-  const explicitPattern = files.filePattern ?? files.pattern ?? files.filename;
-  const explicitPrefix = files.prefix ?? files.appName;
-  if (explicitPattern !== undefined && explicitPrefix !== undefined) {
-    throw new Error('Do not combine "prefix" with "filePattern", pick one: prefix builds "<prefix>-%DATE%.log" for you, filePattern takes full control');
-  }
-  let filename = explicitPattern ?? `${sanitizeAppName(explicitPrefix) ?? getDefaultAppName()}-%DATE%.log`;
-  filename = filename.split('%datePattern%').join('%DATE%');
-  assertFilenameSafe(filename);
-  if (!filename.includes('%DATE%')) {
-    const ext = path.extname(filename) || '.log';
-    const base = path.basename(filename, ext);
-    filename = `${base}-%DATE%${ext}`;
-  }
-  assertFilenameSafe(filename);
-  if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
-  const rawPrefix = path.basename(filename).split('%DATE%')[0];
-  let prefixEnd = rawPrefix.length;
-  while (prefixEnd > 0 && isPadChar(rawPrefix[prefixEnd - 1])) prefixEnd--;
-  const prefix = rawPrefix.slice(0, prefixEnd) || 'application';
-  const runSuffix = resolveRunNumber(folder, sanitizeAppName(prefix) ?? 'application', files.runNumber ?? false);
-  if (runSuffix) {
-    const ext = path.extname(filename) || '.log';
-    const base = filename.slice(0, -ext.length);
-    filename = `${base}${runSuffix}${ext}`;
-  }
-  return {
-    folder,
-    datePattern,
-    filename,
-    maxFiles: files.maxFile ?? files.maxFiles ?? '14d',
-    maxSize: files.maxSize ?? '20m',
-    zippedArchive: files.zippedArchive ?? false,
-    level: files.level,
-  };
-}
-
-function buildConsoleTransport({ enableTimestamp = true, timestampFormat = DEFAULT_CONSOLE_FORMAT, timestampPrefix = '', timestampSuffix = '', colorize = true, level } = {}) {
-  const parts = [];
-  if (colorize) parts.push(format.colorize());
-  if (enableTimestamp) {
-    const stamp = compileTimestampFormatter(timestampFormat);
-    parts.push(format.timestamp({ format: () => `${timestampPrefix}${stamp()}${timestampSuffix}` }));
-  } else {
-    parts.push(format((info) => { delete info.timestamp; return info; })());
-  }
-  parts.push(format.errors({ stack: true }), format.splat(), prettyFormat);
-  return new transports.Console({ format: format.combine(...parts), level });
-}
-
-function buildFileTransport({ folder, datePattern, filename, maxFiles, maxSize, zippedArchive, level }) {
-  if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
-  return new transports.DailyRotateFile({
-    filename: path.join(folder, filename),
-    datePattern,
-    zippedArchive,
-    maxSize,
-    maxFiles,
-    level,
-    format: format.combine(format.errors({ stack: true }), format.splat(), format.timestamp(), prettyFormat),
-  });
-}
-
-function createLoggerInstance(initial = {}) {
-  const globalLevel = process.env.LOG_LEVEL || initial.level || 'debug';
-  assertLevel(globalLevel);
-
-  const logger = createLogger({
-    level: globalLevel,
-    format: format.combine(format.errors({ stack: true }), format.splat()),
-  });
-
-  let consoleTransport = buildConsoleTransport(initial.console);
-  consoleTransport.level = initial.console?.level;
-  logger.add(consoleTransport);
-
-  let fileTransport = null;
-  let consoleOpts = { ...(initial.console || {}) };
-  let filesOpts = null;
-
-  function applySettings(options = {}) {
-    if (options.level !== undefined) {
-      assertLevel(options.level);
-      logger.level = options.level;
-    }
-    if (options.console) {
-      if (options.console.level !== undefined && options.console.level !== null) assertLevel(options.console.level);
-      consoleOpts = { ...consoleOpts, ...options.console };
-      logger.remove(consoleTransport);
-      consoleTransport = buildConsoleTransport(consoleOpts);
-      consoleTransport.level = consoleOpts.level;
-      logger.add(consoleTransport);
-    }
-    if (options.files) {
-      const normalized = normalizeFilesOptions(options.files);
-      if (normalized.level !== undefined && normalized.level !== null) assertLevel(normalized.level);
-      filesOpts = normalized;
-      if (fileTransport) logger.remove(fileTransport);
-      fileTransport = buildFileTransport(normalized);
-      logger.add(fileTransport);
-    }
-  }
-
-  function isEnabled(level) {
-    const want = logger.levels[level];
-    const current = logger.levels[logger.level];
-    return want !== undefined && current !== undefined && want <= current;
-  }
-
-  function write(level, message, ...meta) {
-    if (typeof message === 'function') {
-      if (!isEnabled(level)) return;
-      message = message();
-    }
-    if (message instanceof Error) {
-      logger.log(level, sanitizeMessage(message.message), { stack: message.stack, ...meta[0] });
-      return;
-    }
-    logger.log(level, sanitizeMessage(message), ...meta);
-  }
-
-  function callable(message, ...meta) {
-    write('info', message, ...meta);
-  }
-
-  callable.error = (m, ...a) => write('error', m, ...a);
-  callable.warn = (m, ...a) => write('warn', m, ...a);
-  callable.info = (m, ...a) => write('info', m, ...a);
-  callable.debug = (m, ...a) => write('debug', m, ...a);
-  callable.http = (m, ...a) => write('http', m, ...a);
-  callable.verbose = (m, ...a) => write('verbose', m, ...a);
-  callable.silly = (m, ...a) => write('silly', m, ...a);
-  callable.log = (level, m, ...a) => { assertLevel(level); write(level, m, ...a); };
-
-  callable.settings = applySettings;
-  callable.setLevel = (level) => { assertLevel(level); logger.level = level; };
-  callable.getLevel = () => logger.level;
-  callable.child = (meta = {}) => {
-    const child = logger.child(meta);
-    return {
-      error: (m, ...a) => child.error(m, ...a),
-      warn: (m, ...a) => child.warn(m, ...a),
-      info: (m, ...a) => child.info(m, ...a),
-      debug: (m, ...a) => child.debug(m, ...a),
-      log: child.log.bind(child),
-    };
-  };
-  callable.close = () => {
-    if (fileTransport) { logger.remove(fileTransport); try { fileTransport.close?.(); } catch {} fileTransport = null; }
-  };
-  callable.createLogger = (opts = {}) => createLoggerInstance(opts);
-  callable._winston = logger;
-
-  if (initial.files) applySettings({ files: initial.files });
-  if (initial.console || initial.level) applySettings({ console: initial.console, level: initial.level });
-
-  return callable;
-}
-
-module.exports = createLoggerInstance();
-module.exports.createLogger = createLoggerInstance;
+const fs = require('fs');
+const path = require('path');
+const { MiniLogger, ConsoleTransport, NullTransport, colorizeLevel, resolveLevelColors } = require('./lib/mini');
+const { FileTransport } = require('./lib/rotate');
+const { DEFAULT_CONSOLE_FORMAT, compileTimestampFormatter } = require('./lib/time');
+const { buildLine } = require('./lib/format');
+const { assertLevel, sanitizeMessage } = require('./lib/sanitize');
+const { normalizeFilesOptions } = require('./lib/files');
+
+function normalizeConsoleOpts(input) {
+  if (input === false) return { enabled: false };
+  return input || {};
+}
+
+function buildConsoleTransport({ enabled = true, enableTimestamp = true, timestampFormat = DEFAULT_CONSOLE_FORMAT, timestampPrefix = '', timestampSuffix = '', colorize = true, colors, level } = {}) {
+  if (!enabled) return new NullTransport();
+  const stamp = enableTimestamp ? compileTimestampFormatter(timestampFormat) : null;
+  const palette = resolveLevelColors(colors);
+  const render = ({ level, message, meta }) => {
+    const timestamp = stamp ? `${timestampPrefix}${stamp()}${timestampSuffix}` : '';
+    const tag = colorize ? colorizeLevel(level, `[${level}]`, palette) : `[${level}]`;
+    return buildLine(timestamp, level, message, meta, tag);
+  };
+  return new ConsoleTransport({ level, render });
+}
+
+function buildFileTransport({ folder, datePattern, filename, maxFiles, maxSize, zippedArchive, level }) {
+  if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
+  return new FileTransport({
+    folder: path.normalize(folder),
+    filename,
+    datePattern,
+    zippedArchive,
+    maxSize,
+    maxFiles,
+    level,
+    render: ({ level, message, meta }) => buildLine(new Date().toISOString(), level, message, meta),
+  });
+}
+
+function createLoggerInstance(initial = {}) {
+  const globalLevel = process.env.LOG_LEVEL || initial.level || 'debug';
+  assertLevel(globalLevel);
+
+  const logger = new MiniLogger({ level: globalLevel });
+
+  let consoleTransport = buildConsoleTransport(normalizeConsoleOpts(initial.console));
+  consoleTransport.level = normalizeConsoleOpts(initial.console).level;
+  logger.add(consoleTransport);
+
+  let fileTransport = null;
+  let consoleOpts = { ...normalizeConsoleOpts(initial.console) };
+  let filesOpts = null;
+
+  function applySettings(options = {}) {
+    if (options.level !== undefined) {
+      assertLevel(options.level);
+      logger.level = options.level;
+    }
+    if (options.console !== undefined) {
+      const next = normalizeConsoleOpts(options.console);
+      if (next.level !== undefined && next.level !== null) assertLevel(next.level);
+      consoleOpts = { ...consoleOpts, ...next };
+      logger.remove(consoleTransport);
+      consoleTransport = buildConsoleTransport(consoleOpts);
+      consoleTransport.level = consoleOpts.level;
+      logger.add(consoleTransport);
+    }
+    if (options.files) {
+      const normalized = normalizeFilesOptions(options.files);
+      if (normalized.level !== undefined && normalized.level !== null) assertLevel(normalized.level);
+      filesOpts = normalized;
+      if (fileTransport) logger.remove(fileTransport);
+      fileTransport = buildFileTransport(normalized);
+      logger.add(fileTransport);
+    }
+  }
+
+  function isEnabled(level) {
+    const want = logger.levels[level];
+    const current = logger.levels[logger.level];
+    return want !== undefined && current !== undefined && want <= current;
+  }
+
+  function write(level, message, ...meta) {
+    if (typeof message === 'function') {
+      if (!isEnabled(level)) return;
+      message = message();
+    }
+    if (message instanceof Error) {
+      logger.log(level, sanitizeMessage(message.message), { stack: message.stack, ...meta[0] });
+      return;
+    }
+    logger.log(level, sanitizeMessage(message), ...meta);
+  }
+
+  function callable(message, ...meta) {
+    write('info', message, ...meta);
+  }
+
+  callable.error = (m, ...a) => write('error', m, ...a);
+  callable.warn = (m, ...a) => write('warn', m, ...a);
+  callable.info = (m, ...a) => write('info', m, ...a);
+  callable.debug = (m, ...a) => write('debug', m, ...a);
+  callable.http = (m, ...a) => write('http', m, ...a);
+  callable.verbose = (m, ...a) => write('verbose', m, ...a);
+  callable.silly = (m, ...a) => write('silly', m, ...a);
+  callable.log = (level, m, ...a) => { assertLevel(level); write(level, m, ...a); };
+
+  callable.settings = applySettings;
+  callable.setLevel = (level) => { assertLevel(level); logger.level = level; };
+  callable.getLevel = () => logger.level;
+  callable.child = (meta = {}) => {
+    const child = logger.child(meta);
+    return {
+      error: (m, ...a) => child.error(m, ...a),
+      warn: (m, ...a) => child.warn(m, ...a),
+      info: (m, ...a) => child.info(m, ...a),
+      debug: (m, ...a) => child.debug(m, ...a),
+      log: child.log.bind(child),
+    };
+  };
+  callable.close = () => {
+    if (fileTransport) { logger.remove(fileTransport); try { fileTransport.close?.(); } catch {} fileTransport = null; }
+  };
+  callable.createLogger = (opts = {}) => createLoggerInstance(opts);
+  callable._winston = logger;
+
+  if (initial.files) applySettings({ files: initial.files });
+  if (initial.console || initial.level) applySettings({ console: initial.console, level: initial.level });
+
+  return callable;
+}
+
+module.exports = createLoggerInstance();
+module.exports.createLogger = createLoggerInstance;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logxpert",
-  "version": "2.0.3",
+  "version": "2.1.0",
   "description": "A powerful logging library for Node.js with colorful output and daily file rotation",
   "main": "main.js",
   "types": "index.d.ts",
@@ -22,6 +22,7 @@
     "main.mjs",
     "index.d.ts",
     "index.d.mts",
+    "lib/",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"
@@ -47,14 +48,13 @@
     "node": ">=18"
   },
   "scripts": {
-    "test": "node --test test/logger.test.js",
-    "check:types": "tsc -p test-d --noEmit",
+    "test": "node --test --test-reporter=./test/reporter.js test/logger.test.js test/console.test.js test/files.test.js test/lib.test.js",
+    "test:demo": "node --test --test-reporter=./test/reporter.js demo/reporter.demo.test.js",
+    "check:types": "tsc -p test-d --noEmit && echo TYPES-OK",
     "attw": "attw --pack"
   },
   "dependencies": {
-    "dayjs": "^1.11.23",
-    "winston": "^3.19.0",
-    "winston-daily-rotate-file": "^5.0.0"
+    "dayjs": "^1.11.23"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",