@reliverse/relinka 1.3.6 → 1.3.7

package/README.md

@@ -1,116 +1,154 @@
-# Relidler: Reliverse Bundler
+# Relinka: Stylish Logging Made Simple
 
 [💖 GitHub Sponsors](https://github.com/sponsors/blefnk) • [💬 Discord](https://discord.gg/Pb8uKbwpsJ) • [✨ Repo](https://github.com/reliverse/relinka-logger) • [📦 NPM](https://npmjs.com/@reliverse/relinka) • [📚 Docs](https://docs.reliverse.org)
 
-**@reliverse/relinka** is your next powerful logger, which allows you to style your terminal or browser console like never before.
+**@reliverse/relinka** is your next favorite logging library — built to make your terminal (and browser console — soon) output look good, stay clean, and be actually helpful. It’s styled, structured, and smart. Oh, and it works with configs, files, and colors out of the box.
 
-## Features
+## 🌟 Features
 
-- 😘 Drop-in replacement for `consola`
-- ⚡ `relinka` works via CLI and SDK
-- 📦 Automated NPM/JSR publishing
-- ✅ Ensures reliable JS/TS builds
-- 🔄 Handles automatic version bumps
-- 🔧 Eliminates `package.json` headaches
-- 🎯 Optimized for speed and modern workflows
-- 🛠️ Converts TypeScript aliases to relative paths
-- ✨ Packed with powerful features under the hood
-- 📝 Highly configurable flow via a configuration file
-- 🔌 Plugin system with one built-in plugin included
+- 🧙 Drop-in replacement for `node:console` and `consola`
+- 💬 `relinka` supports: `info`, `warn`, `success`, `error`, `verbose`
+- 🎨 Beautiful, color-coded logs in the terminal
+- 🧠 Auto-formats messages, objects, and errors
+- 📁 Save logs to file (with daily logs, cleanup, and rotation)
+- 📦 Use it programmatically or through CLI-compatible tools
+- ⚙️ Smart customization via config
+- ✨ Extensible and future-proof
 
-## Getting Started
+## 🚀 Getting Started
 
-Ensure [Git](https://git-scm.com/downloads), [Node.js](https://nodejs.org), and a package manager ([bun](https://bun.sh)/[pnpm](https://pnpm.io)/[yarn](https://yarnpkg.com)/[npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm)) are installed. Then follow these steps:
+### 1. Install
 
-### Example Playground
+```bash
+bun add @reliverse/relinka
+```
+
+And, optionally, install the CLI globally to manage your config:
 
-Want to test Relinka before integrating it into your project? Clone the repo and launch the example:
+```bash
+bun i -g @reliverse/relinka-cli
+```
 
-```sh
-git clone https://github.com/reliverse/relinka-logger.git
-cd relinka-logger
-bun i
-bun dev # bun examples/e-main.ts
+### 2. Basic Usage
+
+```ts
+import { relinkaConfig, relinka } from "@reliverse/relinka";
+export async function main() {
+  await relinkaConfig;
+  relinka(
+    "verbose",
+    "This message can be seen only if config was loaded AND debug is enabled",
+  );
+  relinka("info", "Everything is running smoothly");
+  relinka("warn", "This might be a problem");
+  relinka("error", "Uh oh, something broke");
+  relinka("success", "Thanks for using Relinka! 👋");
+}
+await main();
 ```
 
-### Relidler Usage
+## 🧪 Advanced Usage
+
+Want a clean blank line?
 
-1. **Install globally**:
+```ts
+relinka("info", ""); // Just prints a newline
+```
 
-    ```sh
-    bun i -g @reliverse/relidler
-    ```
+🔜 Use the async logger if you want some advanced features (like typing text animation - soon):
 
-    **Or update as needed**:
+```ts
+import { relinkaAsync } from "@reliverse/relinka";
 
-    ```sh
-    bun -g update --latest
-    ```
+await relinkaAsync("info", "Something happened", { animate: true });
+```
 
-2. **Prepare your project**:
+## ⚙️ Configuration
+
+Create a `relinka.config.ts` file with a content like:
+
+```ts
+import { defineConfig } from "@reliverse/relinka";
+export default defineConfig({
+  // Enable debug to see verbose logs
+  debug: true,
+  // Show timestamp in each log message
+  withTimestamp: false,
+  // Control whether logs are saved to a file
+  saveLogsToFile: true,
+  // Disable colors in the console
+  disableColors: false,
+  // Log file path
+  logFilePath: "relinka.log",
+  // Directory settings
+  dirs: {
+    dailyLogs: true,
+    logDir: ".reliverse/logs", // store logs in a custom folder
+    maxLogFiles: 5, // keep only the 5 most recent log files
+    specialDirs: {
+      distDirNames: [],
+      useParentConfigInDist: true,
+    },
+  },
+});
+```
 
-    a. **Configure `.gitignore`**:
+Supported config file names:
 
-    ```sh
-    echo "*.log" >> .gitignore
-    echo "dist-npm" >> .gitignore
-    echo "dist-jsr" >> .gitignore
-    echo "dist-libs" >> .gitignore
-    ```
+- `relinka.config.ts`
+- 🔜 `.relinka.config.js`
+- 🔜 `.relinkarc`
+- 🔜 or any other supported by c12
 
-    b. **Install config intellisense**:
+## 📁 Log Files
 
-    ```sh
-    bun add -D @reliverse/relidler-cfg
-    ```
+- Stored in `.reliverse/logs/` by default
+- Filename: `relinka.log` or `YYYY-MM-DD-relinka.log` if daily logs are enabled
+- Auto-rotates based on `maxLogFiles`
 
-    c. **Initialize `relidler.cfg.ts`**:
+## 📚 API Summary
 
-    ```sh
-    relidler
-    ```
+### relinka(level, message, ...args)
 
-    - The `relidler.cfg.ts` file is created automatically on the first run.
-    - **It's recommended to customize this file according to your needs.**
-    - Supported names: `relidler.cfg.ts` • `relidler.config.ts` • `build.pub.ts` • `build.cfg.ts`.
+Logs synchronously. Skips debug logs if `debug: false`.
 
-3. **Run and enjoy**:
+### relinkaAsync(level, message, ...args)
 
-    ```sh
-    relidler
-    ```
+Async logger that waits for config automatically, and provides some additional advanced features.
 
-## Plugins & SDK
+### defineConfig(config)
 
-Relidler includes a plugin system, with the following official built-in plugin already available:
+Helper to define typed config in `relinka.config.ts`
 
-- **`libraries-relidler-plugin`**: Builds and publishes specified subdirectories of your main project as separate packages.
+## 🧰 Utilities
 
-### API (for advanced users)
+✅ Timestamping  
+✅ Log file rotation  
+✅ File-safe formatting  
+✅ ANSI color support  
+✅ Error object handling
 
-The SDK allows you to create new Relidler plugins and even extend your own CLI functionality.
+## 💡 Tips
 
-```sh
-bun add -D @reliverse/relidler-sdk
-```
+- Want `@ts-expect-error` auto-injection? Check out [`@reliverse/reinject`](https://npmjs.com/@reliverse/reinject).
+- Using this in a CLI tool? Combine with [`@reliverse/prompts`](https://npmjs.com/@reliverse/prompts).
 
-## TODO
+## ✅ TODO
 
-- [x] ~~Implement stable `regular` build and publish~~
-- [ ] Implement stable `library` build and publish
-- [ ] Allow to minify dist with comments preserved
-- [ ] Achieve full drop-in replacement for `unbuild`
-- [ ] Support auto migration from `build.config.ts`
-- [ ] Allow plugins to extend Relidler's `defineConfig`
-- [ ] Support configuration via `reliverse.{ts,jsonc}`
-- [ ] Make config file optional with sensible defaults
+- [x] File-based logging
+- [x] Timestamp support
+- [x] Daily logs
+- [x] Smart config
+- [x] Log rotation
+- [ ] CLI interface (optional)
+- [ ] Plugin support (custom formatters, log levels, etc)
 
-## Related
+## 🙌 Shoutout
 
-Kudos to the following project that made Relinka possible:
+Relinka was inspired by this gem:
 
 - [unjs/consola](https://github.com/unjs/consola#readme)
 
-## License
+## 📄 License
 
-🩷 [MIT](./LICENSE) © [blefnk Nazar Kornienko](https://github.com/blefnk)
+💖 MIT © [blefnk (Nazar Kornienko)](https://github.com/blefnk)

package/bin/main.d.ts

@@ -19,4 +19,4 @@ export { writeStream } from "./relinka-impl/deprecated/utils/stream.js";
 export { stripAnsi, centerAlign, rightAlign, leftAlign, align, } from "./relinka-impl/deprecated/utils/string.js";
 export type { TreeItemObject, TreeItem, TreeOptions, } from "./relinka-impl/deprecated/utils/tree.js";
 export { formatTree } from "./relinka-impl/deprecated/utils/tree.js";
-export { configPromise, relinka, relinkaAsync, defineConfig, } from "./relinka-impl/impl-mod.js";
+export { relinkaConfig, relinka, relinkaAsync, defineConfig, } from "./relinka-impl/impl-mod.js";

package/bin/main.js

@@ -51,7 +51,7 @@ export {
 } from "./relinka-impl/deprecated/utils/string.js";
 export { formatTree } from "./relinka-impl/deprecated/utils/tree.js";
 export {
-  configPromise,
+  relinkaConfig,
   relinka,
   relinkaAsync,
   defineConfig

package/bin/relinka-impl/impl-mod.d.ts

@@ -1,20 +1,19 @@
+import type { RelinkaConfig, LogLevel } from "../relinka-types.js";
 /**
- * Promise that resolves when the Relinka config has been loaded and merged
- * from defaults, environment variables, and optionally config files.
+ * Promise that resolves once c12 loads and merges the config.
  */
-export declare const configPromise: Promise<RelinkaConfig>;
+export declare const relinkaConfig: Promise<RelinkaConfig>;
 /**
  * Logs a message synchronously using the current config.
- * Skips debug-level logs unless `debug` is set to true in the config.
+ * Skips debug-level logs unless `debug` is true in the config.
  */
-export declare const relinka: (type: LogLevel, message: string, ...args: unknown[]) => void;
+export declare function relinka(type: LogLevel, message: string, ...args: unknown[]): void;
 /**
  * Logs a message asynchronously, waiting for the config to be fully loaded.
- * Also handles file writing and log cleanup if enabled in the config.
+ * Also handles file writing and log cleanup if enabled.
  */
-export declare const relinkaAsync: (type: LogLevel, message: string, ...args: unknown[]) => Promise<void>;
+export declare function relinkaAsync(type: LogLevel, message: string, ...args: unknown[]): Promise<void>;
 /**
- * Type helper for defining configuration in `relinka.config.ts` (or similar).
- * Provides autocompletion and type checking for the configuration object.
+ * Type helper for user config files.
  */
-export declare const defineConfig: (config: RelinkaConfig) => RelinkaConfig;
+export declare function defineConfig(config: Partial<RelinkaConfig>): Partial<RelinkaConfig>;

package/bin/relinka-impl/impl-mod.js

@@ -1,13 +1,13 @@
 import { re } from "@reliverse/relico";
 import { loadConfig } from "c12";
 import fs from "fs-extra";
-import { createJiti } from "jiti";
 import path from "pathe";
+const DEV_VERBOSE = false;
 const DEFAULT_RELINKA_CONFIG = {
   debug: false,
   dirs: {
     dailyLogs: false,
-    logDir: ".reliverse",
+    logDir: ".reliverse/logs",
     maxLogFiles: 0,
     specialDirs: {
       distDirNames: ["dist", "dist-jsr", "dist-npm", "dist-libs"],
@@ -19,223 +19,92 @@ const DEFAULT_RELINKA_CONFIG = {
   saveLogsToFile: false,
   withTimestamp: false
 };
-const SUPPORTED_EXTENSIONS = [".ts", ".js", ".mjs", ".cjs", ".json"];
-function isDebugEnabled(config) {
-  return config?.debug ?? DEFAULT_RELINKA_CONFIG.debug;
-}
-function isColorEnabled(config) {
-  return !(config?.disableColors ?? DEFAULT_RELINKA_CONFIG.disableColors);
-}
-function getLogDir(config) {
-  return config?.dirs?.logDir ?? DEFAULT_RELINKA_CONFIG.dirs.logDir;
-}
-function isDailyLogsEnabled(config) {
-  return config?.dirs?.dailyLogs ?? DEFAULT_RELINKA_CONFIG.dirs.dailyLogs;
-}
-function shouldSaveLogs(config) {
-  return config?.saveLogsToFile ?? DEFAULT_RELINKA_CONFIG.saveLogsToFile;
-}
-function getMaxLogFiles(config) {
-  return config?.dirs?.maxLogFiles ?? DEFAULT_RELINKA_CONFIG.dirs.maxLogFiles;
-}
-function getBaseLogName(config) {
-  return config?.logFilePath ?? DEFAULT_RELINKA_CONFIG.logFilePath;
-}
-const getEnvBoolean = (envVarName) => {
-  const value = process.env[envVarName];
-  if (value === void 0 || value === "") return void 0;
-  const lowerValue = value.toLowerCase().trim();
-  return !["0", "false"].includes(lowerValue);
-};
-const getEnvString = (envVarName) => {
-  return process.env[envVarName] || void 0;
-};
-const getEnvNumber = (envVarName) => {
-  const value = process.env[envVarName];
-  if (value === void 0) return void 0;
-  const parsed = Number.parseInt(value, 10);
-  return Number.isNaN(parsed) ? void 0 : parsed;
-};
-const getEnvOverrides = () => {
-  const overrides = {};
-  const dirsOverride = {};
-  const specialDirsOverride = {};
-  const debug = getEnvBoolean("RELINKA_DEBUG");
-  if (debug !== void 0) overrides.debug = debug;
-  const withTimestamp = getEnvBoolean("RELINKA_TIMESTAMP");
-  if (withTimestamp !== void 0) overrides.withTimestamp = withTimestamp;
-  const disableColors = getEnvBoolean("RELINKA_DISABLE_COLORS");
-  if (disableColors !== void 0) overrides.disableColors = disableColors;
-  const saveLogsToFile = getEnvBoolean("RELINKA_SAVE_LOGS");
-  if (saveLogsToFile !== void 0) overrides.saveLogsToFile = saveLogsToFile;
-  const logFilePath = getEnvString("RELINKA_LOG_FILE");
-  if (logFilePath !== void 0) overrides.logFilePath = logFilePath;
-  const logDir = getEnvString("RELINKA_LOG_DIR");
-  if (logDir !== void 0) dirsOverride.logDir = logDir;
-  const dailyLogs = getEnvBoolean("RELINKA_DAILY_LOGS");
-  if (dailyLogs !== void 0) dirsOverride.dailyLogs = dailyLogs;
-  const maxLogFiles = getEnvNumber("RELINKA_MAX_LOG_FILES");
-  if (maxLogFiles !== void 0) dirsOverride.maxLogFiles = maxLogFiles;
-  const useParentConfig = getEnvBoolean("RELINKA_USE_PARENT_CONFIG");
-  if (useParentConfig !== void 0) {
-    specialDirsOverride.useParentConfigInDist = useParentConfig;
-  }
-  if (Object.keys(specialDirsOverride).length > 0) {
-    dirsOverride.specialDirs = specialDirsOverride;
-  }
-  if (Object.keys(dirsOverride).length > 0) {
-    overrides.dirs = dirsOverride;
-  }
-  return overrides;
-};
 let currentConfig = { ...DEFAULT_RELINKA_CONFIG };
 let isConfigInitialized = false;
-let resolveConfigPromise;
-export const configPromise = new Promise((resolve) => {
-  resolveConfigPromise = resolve;
+let resolveRelinkaConfig;
+export const relinkaConfig = new Promise((resolve) => {
+  resolveRelinkaConfig = resolve;
 });
-const findConfigFile = (basePath) => {
-  for (const ext of SUPPORTED_EXTENSIONS) {
-    const filePath = basePath + ext;
-    if (fs.existsSync(filePath)) {
-      return filePath;
-    }
-  }
-  return void 0;
-};
-const initializeConfig = async () => {
+async function initializeConfig() {
   try {
-    const envOverrides = getEnvOverrides();
-    const projectRoot = process.cwd();
-    const reliverseDir = path.resolve(projectRoot, ".reliverse");
-    const configName = "relinka";
-    const resolveConfig = async (id, options) => {
-      if (id !== configName) {
-        return null;
-      }
-      const effectiveCwd = options.cwd || projectRoot;
-      const _jitiRequire = createJiti(effectiveCwd, options.jitiOptions);
-      const loadAndExtract = async (filePath) => {
-        try {
-          const loadedModule = await _jitiRequire.import(filePath);
-          const configData = loadedModule.default || loadedModule;
-          return configData;
-        } catch (error) {
-          console.error(
-            `[Relinka Config Error] Failed to load or parse config from ${filePath}: ${error instanceof Error ? error.message : String(error)}`
-          );
-          return null;
-        }
-      };
-      const reliverseBasePath = path.resolve(reliverseDir, configName);
-      const reliverseConfigFile = findConfigFile(reliverseBasePath);
-      if (reliverseConfigFile) {
-        const config = await loadAndExtract(reliverseConfigFile);
-        if (config !== null) {
-          return { config, source: reliverseConfigFile };
-        }
-      }
-      const rootBasePath = path.resolve(effectiveCwd, configName);
-      const rootConfigFile = findConfigFile(rootBasePath);
-      if (rootConfigFile) {
-        const config = await loadAndExtract(rootConfigFile);
-        if (config !== null) {
-          return { config, source: rootConfigFile };
-        }
-      }
-      return null;
-    };
-    const loadedConfigResult = await loadConfig({
-      name: configName,
-      cwd: projectRoot,
-      resolve: resolveConfig,
-      packageJson: "relinka",
-      dotenv: true,
-      defaults: DEFAULT_RELINKA_CONFIG,
-      overrides: envOverrides
+    const result = await loadConfig({
+      name: "relinka",
+      // base name => tries relinka.config.*, .relinkarc, etc.
+      cwd: process.cwd(),
+      // working directory
+      dotenv: false,
+      packageJson: false,
+      rcFile: false,
+      globalRc: false,
+      defaults: DEFAULT_RELINKA_CONFIG
+      // lowest priority
+      // overrides: {},       // highest priority if we would need to forcibly override
     });
-    currentConfig = loadedConfigResult.config ?? { ...DEFAULT_RELINKA_CONFIG };
+    currentConfig = result.config;
     isConfigInitialized = true;
-    const customResolvedLayer = loadedConfigResult.layers?.find(
-      (layer) => layer.source?.includes(configName)
-    );
-    if (customResolvedLayer?.source) {
+    if (DEV_VERBOSE) {
       console.log(
-        `[Relinka Config] Loaded main configuration from: ${path.relative(
-          projectRoot,
-          customResolvedLayer.source
-        )}`
+        "[Relinka Config Debug] Config file used:",
+        result.configFile
       );
-    } else {
-      const pkgJsonLayer = loadedConfigResult.layers?.find(
-        (layer) => layer.source?.endsWith("package.json")
-      );
-      if (pkgJsonLayer?.config) {
-        console.log("[Relinka Config] Loaded configuration from package.json.");
-      } else {
-        console.log(
-          "[Relinka Config] No config file or package.json entry found. Using defaults and environment variables."
-        );
-      }
+      console.log("[Relinka Config Debug] All merged layers:", result.layers);
+      console.log("[Relinka Config Debug] Final configuration:", currentConfig);
     }
-    if (isDebugEnabled(currentConfig)) {
-      console.log(
-        "[Relinka Config Debug] Final configuration object:",
-        JSON.stringify(currentConfig, null, 2)
-      );
-      console.log(
-        "[Relinka Config Debug] Resolved layers:",
-        loadedConfigResult.layers?.map((l) => ({
-          config: l.config ? "[Object]" : null,
-          source: l.source ? path.relative(projectRoot, l.source) : void 0,
-          meta: l.meta
-        }))
-      );
-    }
-    if (resolveConfigPromise) {
-      resolveConfigPromise(currentConfig);
+    if (resolveRelinkaConfig) {
+      resolveRelinkaConfig(currentConfig);
     }
-    return currentConfig;
-  } catch (error) {
+  } catch (err) {
     console.error(
-      `[Relinka Config Error] Failed during configuration loading process: ${error instanceof Error ? error.message : String(error)}`
+      `[Relinka Config Error] Failed to load config: ${err instanceof Error ? err.message : String(err)}`
     );
     currentConfig = { ...DEFAULT_RELINKA_CONFIG };
     isConfigInitialized = true;
-    if (resolveConfigPromise) {
-      resolveConfigPromise(currentConfig);
+    if (resolveRelinkaConfig) {
+      resolveRelinkaConfig(currentConfig);
     }
-    return currentConfig;
   }
-};
+}
 initializeConfig().catch((err) => {
   console.error(
-    `[Relinka Config Error] Unhandled error during initial configuration load: ${err instanceof Error ? err.message : String(err)}`
+    `[Relinka Config Error] Unhandled error: ${err instanceof Error ? err.message : String(err)}`
   );
   if (!isConfigInitialized) {
     currentConfig = { ...DEFAULT_RELINKA_CONFIG };
     isConfigInitialized = true;
-    if (resolveConfigPromise) {
-      resolveConfigPromise(currentConfig);
+    if (resolveRelinkaConfig) {
+      resolveRelinkaConfig(currentConfig);
     }
   }
 });
-const getTimestamp = (config) => {
-  if (!config?.withTimestamp) return "";
+function isDebugEnabled(config) {
+  return config.debug ?? DEFAULT_RELINKA_CONFIG.debug;
+}
+function isColorEnabled(config) {
+  return !(config.disableColors ?? DEFAULT_RELINKA_CONFIG.disableColors);
+}
+function getLogDir(config) {
+  return config.dirs?.logDir ?? DEFAULT_RELINKA_CONFIG.dirs.logDir;
+}
+function isDailyLogsEnabled(config) {
+  return config.dirs?.dailyLogs ?? DEFAULT_RELINKA_CONFIG.dirs.dailyLogs;
+}
+function shouldSaveLogs(config) {
+  return config.saveLogsToFile ?? DEFAULT_RELINKA_CONFIG.saveLogsToFile;
+}
+function getMaxLogFiles(config) {
+  return config.dirs?.maxLogFiles ?? DEFAULT_RELINKA_CONFIG.dirs.maxLogFiles;
+}
+function getBaseLogName(config) {
+  return config.logFilePath ?? DEFAULT_RELINKA_CONFIG.logFilePath;
+}
+function getTimestamp(config) {
+  if (!config.withTimestamp) return "";
   const now = /* @__PURE__ */ new Date();
-  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(
-    2,
-    "0"
-  )}-${String(now.getDate()).padStart(2, "0")} ${String(
-    now.getHours()
-  ).padStart(2, "0")}:${String(now.getMinutes()).padStart(
-    2,
-    "0"
-  )}:${String(now.getSeconds()).padStart(2, "0")}.${String(
-    now.getMilliseconds()
-  ).padStart(3, "0")}`;
-};
-const getLogFilePath = (config) => {
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")} ${String(now.getHours()).padStart(2, "0")}:${String(
+    now.getMinutes()
+  ).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}.${String(now.getMilliseconds()).padStart(3, "0")}`;
+}
+function getLogFilePath(config) {
   const logDir = getLogDir(config);
   const daily = isDailyLogsEnabled(config);
   let finalLogName = getBaseLogName(config);
@@ -251,8 +120,8 @@ const getLogFilePath = (config) => {
   }
   const effectiveLogName = finalLogName || "relinka.log";
   return path.resolve(process.cwd(), logDir, effectiveLogName);
-};
-const formatLogMessage = (config, level, msg, details) => {
+}
+function formatLogMessage(config, level, msg, details) {
   const timestamp = getTimestamp(config);
   let detailsStr = "";
   if (details !== void 0) {
@@ -271,101 +140,101 @@ Stack Trace: ${details.stack || details.message}`;
   }
   const paddedLevel = level.padEnd(7, " ");
   return timestamp ? `[${timestamp}] ${paddedLevel} ${msg}${detailsStr}` : `${paddedLevel} ${msg}${detailsStr}`;
-};
-const logToConsole = (config, level, formattedMessage) => {
+}
+function logToConsole(config, level, formattedMessage) {
+  const COLOR_RESET = "\x1B[0m";
   if (!isColorEnabled(config)) {
-    switch (level) {
-      case "ERROR":
-        console.error(formattedMessage);
-        break;
-      default:
-        console.log(formattedMessage);
+    if (level === "ERROR") {
+      console.error(formattedMessage);
+    } else {
+      console.log(formattedMessage);
     }
   } else {
     switch (level) {
       case "ERROR":
-        console.error(re.redBright(formattedMessage));
+        console.error(re.redBright(formattedMessage) + COLOR_RESET);
         break;
       case "WARN":
-        console.warn(re.yellowBright(formattedMessage));
+        console.warn(re.yellowBright(formattedMessage) + COLOR_RESET);
         break;
       case "SUCCESS":
-        console.log(re.greenBright(formattedMessage));
+        console.log(re.greenBright(formattedMessage) + COLOR_RESET);
         break;
       case "INFO":
-        console.log(re.cyanBright(formattedMessage));
+        console.log(re.cyanBright(formattedMessage) + COLOR_RESET);
         break;
       default:
-        console.log(re.dim(formattedMessage));
+        console.log(re.dim(formattedMessage) + COLOR_RESET);
     }
   }
-};
-const getLogFilesSortedByDate = async (config) => {
+}
+async function getLogFilesSortedByDate(config) {
   const logDirectoryPath = path.resolve(process.cwd(), getLogDir(config));
-  const debugEnabled = isDebugEnabled(config);
-  try {
-    if (!await fs.pathExists(logDirectoryPath)) {
-      if (debugEnabled) {
-        console.log(
-          `[Relinka FS Debug] Log directory does not exist: ${logDirectoryPath}`
-        );
-      }
-      return [];
+  if (!await fs.pathExists(logDirectoryPath)) {
+    if (isDebugEnabled(config)) {
+      console.log(
+        `[Relinka FS Debug] Log directory not found: ${logDirectoryPath}`
+      );
     }
+    return [];
+  }
+  try {
     const files = await fs.readdir(logDirectoryPath);
-    const logFilesPromises = files.filter((file) => file.endsWith(".log")).map(async (file) => {
-      const filePath = path.join(logDirectoryPath, file);
+    const logFilesPromises = files.filter((f) => f.endsWith(".log")).map(async (f) => {
+      const filePath = path.join(logDirectoryPath, f);
       try {
         const stats = await fs.stat(filePath);
-        return stats.isFile() ? { path: filePath, mtime: stats.mtime.getTime() } : null;
-      } catch (statError) {
-        if (debugEnabled) {
+        if (stats.isFile()) {
+          return { path: filePath, mtime: stats.mtime.getTime() };
+        }
+        return null;
+      } catch (err) {
+        if (isDebugEnabled(config)) {
           console.error(
-            `[Relinka FS Debug] Error stating file ${filePath}: ${statError instanceof Error ? statError.message : String(statError)}`
+            `[Relinka FS Debug] Error reading stats for ${filePath}: ${err instanceof Error ? err.message : String(err)}`
           );
         }
         return null;
       }
     });
     const logFiles = (await Promise.all(logFilesPromises)).filter(
-      (fileInfo) => Boolean(fileInfo)
+      (f) => Boolean(f)
     );
     return logFiles.sort((a, b) => b.mtime - a.mtime);
-  } catch (readDirError) {
-    if (debugEnabled) {
+  } catch (readErr) {
+    if (isDebugEnabled(config)) {
       console.error(
-        `[Relinka FS Error] Error reading log directory ${logDirectoryPath}: ${readDirError instanceof Error ? readDirError.message : String(readDirError)}`
+        `[Relinka FS Error] Failed reading log directory ${logDirectoryPath}: ${readErr instanceof Error ? readErr.message : String(readErr)}`
       );
     }
     return [];
   }
-};
-const deleteFiles = async (filePaths, config) => {
-  const debugEnabled = isDebugEnabled(config);
-  const deletePromises = filePaths.map(async (filePath) => {
-    try {
-      await fs.unlink(filePath);
-    } catch (unlinkErr) {
-      if (debugEnabled) {
-        console.error(
-          `[Relinka FS Error] Failed to delete log file ${filePath}: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`
-        );
+}
+async function deleteFiles(filePaths, config) {
+  await Promise.all(
+    filePaths.map(async (filePath) => {
+      try {
+        await fs.unlink(filePath);
+      } catch (err) {
+        if (isDebugEnabled(config)) {
+          console.error(
+            `[Relinka FS Error] Failed to delete log file ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
       }
-    }
-  });
-  await Promise.all(deletePromises);
-};
-const cleanupOldLogFiles = async (config) => {
-  const maxFiles = getMaxLogFiles(config);
-  const debugEnabled = isDebugEnabled(config);
-  if (!shouldSaveLogs(config) || maxFiles <= 0) return;
+    })
+  );
+}
+async function cleanupOldLogFiles(config) {
+  if (!shouldSaveLogs(config) || getMaxLogFiles(config) <= 0) return;
   try {
     const sortedLogFiles = await getLogFilesSortedByDate(config);
+    const maxFiles = getMaxLogFiles(config);
     if (sortedLogFiles.length > maxFiles) {
       const filesToDelete = sortedLogFiles.slice(maxFiles).map((f) => f.path);
       if (filesToDelete.length > 0) {
         await deleteFiles(filesToDelete, config);
-        if (debugEnabled) {
+        if (isDebugEnabled(config)) {
           console.log(
             `[Relinka Cleanup] Deleted ${filesToDelete.length} old log file(s). Kept ${maxFiles}.`
           );
@@ -373,82 +242,76 @@ const cleanupOldLogFiles = async (config) => {
       }
     }
   } catch (err) {
-    if (debugEnabled) {
+    if (isDebugEnabled(config)) {
       console.error(
         `[Relinka Cleanup Error] Failed during log cleanup: ${err instanceof Error ? err.message : String(err)}`
       );
     }
   }
-};
-const appendToLogFile = async (config, absoluteLogFilePath, logMessage) => {
-  const debugEnabled = isDebugEnabled(config);
+}
+async function appendToLogFile(config, absoluteLogFilePath, logMessage) {
   try {
     await fs.ensureDir(path.dirname(absoluteLogFilePath));
     await fs.appendFile(absoluteLogFilePath, `${logMessage}
 `);
   } catch (err) {
-    if (debugEnabled) {
+    if (isDebugEnabled(config)) {
       console.error(
         `[Relinka File Error] Failed to write to log file ${absoluteLogFilePath}: ${err instanceof Error ? err.message : String(err)}`
       );
     }
   }
-};
-export const relinka = (type, message, ...args) => {
-  const configToUse = currentConfig;
+}
+export function relinka(type, message, ...args) {
   if (message === "") {
     console.log();
     return;
   }
   const logLevelLabel = type === "verbose" ? "DEBUG" : type.toUpperCase();
-  if (logLevelLabel === "DEBUG" && !isDebugEnabled(configToUse)) {
+  if (logLevelLabel === "DEBUG" && !isDebugEnabled(currentConfig)) {
     return;
   }
-  const details = args.length > 0 ? args.length === 1 ? args[0] : args : void 0;
-  const formattedMessage = formatLogMessage(
-    configToUse,
+  const details = args.length > 1 ? args : args[0];
+  const formatted = formatLogMessage(
+    currentConfig,
     logLevelLabel,
     message,
     details
   );
-  logToConsole(configToUse, logLevelLabel, formattedMessage);
-};
-export const relinkaAsync = async (type, message, ...args) => {
-  const loadedConfig = await configPromise;
+  logToConsole(currentConfig, logLevelLabel, formatted);
+}
+export async function relinkaAsync(type, message, ...args) {
+  await relinkaConfig;
   if (message === "") {
     console.log();
     return;
   }
   const logLevelLabel = type === "verbose" ? "DEBUG" : type.toUpperCase();
-  if (logLevelLabel === "DEBUG" && !isDebugEnabled(loadedConfig)) {
+  if (logLevelLabel === "DEBUG" && !isDebugEnabled(currentConfig)) {
     return;
   }
-  const details = args.length > 0 ? args.length === 1 ? args[0] : args : void 0;
-  const formattedMessage = formatLogMessage(
-    loadedConfig,
+  const details = args.length > 1 ? args : args[0];
+  const formatted = formatLogMessage(
+    currentConfig,
     logLevelLabel,
     message,
     details
   );
-  logToConsole(loadedConfig, logLevelLabel, formattedMessage);
-  if (shouldSaveLogs(loadedConfig)) {
-    const absoluteLogFilePath = getLogFilePath(loadedConfig);
+  logToConsole(currentConfig, logLevelLabel, formatted);
+  if (shouldSaveLogs(currentConfig)) {
+    const absoluteLogFilePath = getLogFilePath(currentConfig);
     try {
-      await appendToLogFile(
-        loadedConfig,
-        absoluteLogFilePath,
-        formattedMessage
-      );
-      await cleanupOldLogFiles(loadedConfig);
+      await appendToLogFile(currentConfig, absoluteLogFilePath, formatted);
+      await cleanupOldLogFiles(currentConfig);
     } catch (err) {
-      if (isDebugEnabled(loadedConfig)) {
+      if (isDebugEnabled(currentConfig)) {
         console.error(
-          `[Relinka File Async Error] Error during file logging/cleanup process: ${err instanceof Error ? err.message : String(err)}`
+          `[Relinka File Async Error] Error during file logging/cleanup: ${err instanceof Error ? err.message : String(err)}`
         );
       }
     }
   }
-};
-export const defineConfig = (config) => {
+}
+export function defineConfig(config) {
   return config;
-};
+}

package/package.json

@@ -1,11 +1,11 @@
 {
-  "description": "@reliverse/relinka is a powerful logger for your terminal.",
+  "description": "@reliverse/relinka is your next favorite logging library — built to make your terminal (and browser console — soon) output look good, stay clean, and be actually helpful. It’s styled, structured, and smart. Oh, and it works with configs, files, and colors out of the box.",
   "license": "MIT",
   "name": "@reliverse/relinka",
   "type": "module",
-  "version": "1.3.6",
+  "version": "1.3.7",
   "dependencies": {
-    "@reliverse/relico": "^1.0.2",
+    "@reliverse/relico": "^1.1.0",
     "@reliverse/runtime": "^1.0.3",
     "c12": "^3.0.2",
     "defu": "^6.1.4",