@reliverse/relinka 1.5.2 → 1.5.4

package/bin/impl.d.ts

@@ -1,115 +1,10 @@
-import type { DefaultColorKeys } from "@reliverse/relico";
-/** Configuration for special directory handling. */
-export type RelinkaSpecialDirsConfig = {
-    distDirNames?: string[];
-    useParentConfigInDist?: boolean;
-};
-/** Configuration for directory-related settings. */
-export type RelinkaDirsConfig = {
-    dailyLogs?: boolean;
-    logDir?: string;
-    maxLogFiles?: number;
-    specialDirs?: RelinkaSpecialDirsConfig;
-};
-/** Configuration for a single log level. */
-export type LogLevelConfig = {
-    /**
-     * Symbol to display for this log level.
-     * @see https://symbl.cc
-     */
-    symbol: string;
-    /**
-     * Fallback symbol to use if Unicode is not supported.
-     */
-    fallbackSymbol: string;
-    /**
-     * Color to use for this log level.
-     */
-    color: DefaultColorKeys;
-    /**
-     * Number of spaces after the symbol/fallback
-     */
-    spacing?: number;
-};
-/** Configuration for all log levels. */
-export type LogLevelsConfig = Partial<Record<LogLevel, LogLevelConfig>>;
-/** Log level types used by the logger. */
-export type LogLevel = "error" | "fatal" | "info" | "success" | "verbose" | "warn" | "log" | "internal" | "null" | "step" | "box" | "message";
+import { type LogLevel, type RelinkaConfig, type RelinkaConfigOptions, type RelinkaFunction } from "./setup";
+/** Promise resolved once the user's config (if any) is merged. */
+export declare const loadRelinkaConfig: Promise<RelinkaConfig>;
 /**
- * Configuration options for the Relinka logger.
- * All properties are optional to allow for partial configuration.
- * Defaults will be applied during initialization.
+ * Enhanced relinkaConfig function that accepts options
  */
-export type RelinkaConfig = {
-    /**
-     * Enables verbose (aka debug) mode for detailed logging.
-     *
-     * `true` here works only for end-users of CLIs/libs when theirs developers
-     * has been awaited for user's config via `@reliverse/relinka`'s `await relinkaConfig;`
-     */
-    verbose?: boolean;
-    /**
-     * Configuration for directory-related settings.
-     * - `dailyLogs`: If true, logs will be stored in a daily subdirectory.
-     * - `logDir`: The base directory for logs.
-     * - `maxLogFiles`: The maximum number of log files to keep before cleanup.
-     * - `specialDirs`: Configuration for special directory handling.
-     *   - `distDirNames`: An array of directory names to check for special handling.
-     *   - `useParentConfigInDist`: If true, use the parent config in dist directories.
-     */
-    dirs?: RelinkaDirsConfig;
-    /**
-     * Disables color output in the console.
-     */
-    disableColors?: boolean;
-    /**
-     * Path to the log file.
-     */
-    logFilePath?: string;
-    /**
-     * If true, logs will be saved to a file.
-     */
-    saveLogsToFile?: boolean;
-    /**
-     * Configuration for timestamp in log messages.
-     */
-    timestamp?: {
-        /**
-         * If true, timestamps will be added to log messages.
-         */
-        enabled: boolean;
-        /**
-         * The format for timestamps. Default is YYYY-MM-DD HH:mm:ss.SSS
-         */
-        format?: string;
-    };
-    /**
-     * Allows to customize the log levels.
-     */
-    levels?: LogLevelsConfig;
-    /**
-     * Controls how often the log cleanup runs (in milliseconds)
-     * Default: 10000 (10 seconds)
-     */
-    cleanupInterval?: number;
-    /**
-     * Maximum size of the log write buffer before flushing to disk (in bytes)
-     * Default: 4096 (4KB)
-     */
-    bufferSize?: number;
-    /**
-     * Maximum time to hold logs in buffer before flushing to disk (in milliseconds)
-     * Default: 5000 (5 seconds)
-     */
-    maxBufferAge?: number;
-};
-/** Represents information about a log file for cleanup purposes. */
-export type LogFileInfo = {
-    path: string;
-    mtime: number;
-};
-/** Promise resolved once the user's config (if any) is merged. */
-export declare const relinkaConfig: Promise<RelinkaConfig>;
+export declare function relinkaConfig(options?: RelinkaConfigOptions): Promise<RelinkaConfig>;
 /**
  * Shuts down the logger, flushing all buffers and clearing timers.
  * As Relinka user - call this at the end of your program to prevent hanging.
@@ -131,25 +26,6 @@ export declare function truncateString(msg: string, maxLength?: number): string;
  * Exhaustiveness check. If we land here, we missed a union case.
  */
 export declare function casesHandled(unexpectedCase: never): never;
-/**
- * Enhanced relinka function type that supports both traditional and method syntax
- */
-export type RelinkaFunction = {
-    (type: LogLevel | "clear", message: string, ...args: unknown[]): undefined | never;
-    error(message: string, ...args: unknown[]): void;
-    fatal(message: string, ...args: unknown[]): never;
-    info(message: string, ...args: unknown[]): void;
-    success(message: string, ...args: unknown[]): void;
-    verbose(message: string, ...args: unknown[]): void;
-    warn(message: string, ...args: unknown[]): void;
-    log(message: string, ...args: unknown[]): void;
-    internal(message: string, ...args: unknown[]): void;
-    null(message: string, ...args: unknown[]): void;
-    step(message: string, ...args: unknown[]): void;
-    box(message: string, ...args: unknown[]): void;
-    message(message: string, ...args: unknown[]): void;
-    clear(): void;
-};
 /**
  * Logs a message synchronously using the current config.
  * If type === "fatal", logs a fatal error and throws (never returns).

package/bin/impl.js

@@ -3,98 +3,11 @@ import { re } from "@reliverse/relico";
 import fs from "@reliverse/relifso";
 import { loadConfig } from "c12";
 import os from "node:os";
-const ENABLE_DEV_DEBUG = false;
-const EXIT_GUARD = Symbol.for("relinka.exitHandlersRegistered");
-const DEFAULT_RELINKA_CONFIG = {
-  verbose: false,
-  dirs: {
-    dailyLogs: false,
-    logDir: "logs",
-    maxLogFiles: 0,
-    specialDirs: {
-      distDirNames: ["dist", "dist-jsr", "dist-npm", "dist-libs"],
-      useParentConfigInDist: true
-    }
-  },
-  disableColors: false,
-  logFilePath: "relinka.log",
-  saveLogsToFile: false,
-  timestamp: {
-    enabled: false,
-    format: "YYYY-MM-DD HH:mm:ss.SSS"
-  },
-  cleanupInterval: 1e4,
-  // 10 seconds
-  bufferSize: 4096,
-  // 4KB
-  maxBufferAge: 5e3,
-  // 5 seconds
-  // A default set of levels, with fallback symbols for non-Unicode terminals:
-  levels: {
-    success: {
-      symbol: "\u2713",
-      fallbackSymbol: "[OK]",
-      color: "greenBright",
-      spacing: 3
-    },
-    info: {
-      symbol: "\u25C8",
-      fallbackSymbol: "[i]",
-      color: "cyanBright",
-      spacing: 3
-    },
-    error: {
-      symbol: "\u2716",
-      fallbackSymbol: "[ERR]",
-      color: "redBright",
-      spacing: 3
-    },
-    warn: {
-      symbol: "\u26A0",
-      fallbackSymbol: "[WARN]",
-      color: "yellowBright",
-      spacing: 3
-    },
-    fatal: {
-      symbol: "\u203C",
-      fallbackSymbol: "[FATAL]",
-      color: "redBright",
-      spacing: 3
-    },
-    verbose: {
-      symbol: "\u2731",
-      fallbackSymbol: "[VERBOSE]",
-      color: "gray",
-      spacing: 3
-    },
-    internal: {
-      symbol: "\u2699",
-      fallbackSymbol: "[INTERNAL]",
-      color: "magentaBright",
-      spacing: 3
-    },
-    log: { symbol: "\u2502", fallbackSymbol: "|", color: "dim", spacing: 3 },
-    step: {
-      symbol: "\u2192",
-      fallbackSymbol: "[STEP]",
-      color: "blueBright",
-      spacing: 3
-    },
-    box: {
-      symbol: "\u25A0",
-      fallbackSymbol: "[BOX]",
-      color: "whiteBright",
-      spacing: 1
-    },
-    message: {
-      symbol: "\u{1F7A0}",
-      fallbackSymbol: "[MSG]",
-      color: "cyan",
-      spacing: 3
-    },
-    null: { symbol: "", fallbackSymbol: "", color: "dim", spacing: 0 }
-  }
-};
+import {
+  DEFAULT_RELINKA_CONFIG,
+  ENABLE_DEV_DEBUG,
+  EXIT_GUARD
+} from "./setup.js";
 function isUnicodeSupported() {
   if (process.env.TERM_PROGRAM === "vscode" || process.env.WT_SESSION || process.env.TERM_PROGRAM === "iTerm.app" || process.env.TERM_PROGRAM === "hyper" || process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm" || process.env.ConEmuTask === "{cmd::Cmder}" || process.env.TERM === "xterm-256color") {
     return true;
@@ -115,9 +28,33 @@ function isUnicodeSupported() {
 let currentConfig = { ...DEFAULT_RELINKA_CONFIG };
 let isConfigInitialized = false;
 let resolveRelinkaConfig;
-export const relinkaConfig = new Promise((res) => {
+let userTerminalCwd;
+export const loadRelinkaConfig = new Promise((res) => {
   resolveRelinkaConfig = res;
 });
+export async function relinkaConfig(options = {}) {
+  if (!userTerminalCwd) {
+    userTerminalCwd = process.cwd();
+  }
+  const config = await loadRelinkaConfig;
+  if (options.supportFreshLogFile && isFreshLogFileEnabled(config)) {
+    try {
+      const logFilePath = getLogFilePath(config);
+      await fs.ensureDir(path.dirname(logFilePath));
+      await fs.writeFile(logFilePath, "");
+      if (isVerboseEnabled(config)) {
+        console.log(`[Relinka Fresh Log] Cleared log file: ${logFilePath}`);
+      }
+    } catch (err) {
+      if (isVerboseEnabled(config)) {
+        console.error(
+          `[Relinka Fresh Log Error] Failed to clear log file: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+  return config;
+}
 const logBuffers = /* @__PURE__ */ new Map();
 const activeTimers = [];
 let bufferFlushTimer = null;
@@ -125,22 +62,52 @@ let lastCleanupTime = 0;
 let cleanupScheduled = false;
 async function initializeConfig() {
   try {
-    const result = await loadConfig({
-      name: "relinka",
-      cwd: process.cwd(),
-      dotenv: false,
-      packageJson: false,
-      rcFile: false,
-      globalRc: false,
-      defaults: DEFAULT_RELINKA_CONFIG
-    });
-    currentConfig = result.config;
+    let result;
+    try {
+      result = await loadConfig({
+        name: "dler",
+        // name: "relinka",
+        cwd: process.cwd(),
+        dotenv: false,
+        packageJson: false,
+        rcFile: false,
+        globalRc: false,
+        defaults: {}
+      });
+      if (result.config?.relinka) {
+        currentConfig = { ...DEFAULT_RELINKA_CONFIG, ...result.config.relinka };
+        if (ENABLE_DEV_DEBUG) {
+          console.log("[Dev Debug] Using relinka config from dler config");
+        }
+      } else {
+        currentConfig = { ...DEFAULT_RELINKA_CONFIG };
+        if (ENABLE_DEV_DEBUG) {
+          console.log(
+            "[Dev Debug] No relinka config in dler config, using defaults"
+          );
+        }
+      }
+    } catch {
+      const relinkaResult = await loadConfig({
+        name: "relinka",
+        cwd: process.cwd(),
+        dotenv: false,
+        packageJson: false,
+        rcFile: false,
+        globalRc: false,
+        defaults: DEFAULT_RELINKA_CONFIG
+      });
+      currentConfig = relinkaResult.config;
+      if (ENABLE_DEV_DEBUG) {
+        console.log(
+          "[Dev Debug] Dler config loading failed, using separate relinka config"
+        );
+      }
+    }
     isConfigInitialized = true;
     resolveRelinkaConfig?.(currentConfig);
     resolveRelinkaConfig = void 0;
     if (ENABLE_DEV_DEBUG) {
-      console.log("[Dev Debug] Config file used:", result.configFile);
-      console.log("[Dev Debug] All merged layers:", result.layers);
       console.log("[Dev Debug] Final configuration:", currentConfig);
     }
   } catch (err) {
@@ -193,20 +160,15 @@ function isVerboseEnabled(config) {
 function isColorEnabled(config) {
   return !(config.disableColors ?? DEFAULT_RELINKA_CONFIG.disableColors);
 }
-function getLogDir(config) {
-  return config.dirs?.logDir ?? DEFAULT_RELINKA_CONFIG.dirs?.logDir ?? "logs";
-}
-function isDailyLogsEnabled(config) {
-  return config.dirs?.dailyLogs ?? DEFAULT_RELINKA_CONFIG.dirs?.dailyLogs ?? false;
-}
 function shouldSaveLogs(config) {
   return config.saveLogsToFile ?? DEFAULT_RELINKA_CONFIG.saveLogsToFile ?? false;
 }
 function getMaxLogFiles(config) {
-  return config.dirs?.maxLogFiles ?? DEFAULT_RELINKA_CONFIG.dirs?.maxLogFiles ?? 0;
+  return config.dirs?.maxLogFiles ?? 0;
 }
 function getBaseLogName(config) {
-  return config.logFilePath ?? DEFAULT_RELINKA_CONFIG.logFilePath ?? "relinka.log";
+  const logFileConfig = config.logFile || DEFAULT_RELINKA_CONFIG.logFile || {};
+  return logFileConfig.outputPath ?? "logs.log";
 }
 function getBufferSize(config) {
   return config.bufferSize ?? DEFAULT_RELINKA_CONFIG.bufferSize ?? 4096;
@@ -217,6 +179,9 @@ function getMaxBufferAge(config) {
 function getCleanupInterval(config) {
   return config.cleanupInterval ?? DEFAULT_RELINKA_CONFIG.cleanupInterval ?? 1e4;
 }
+function isFreshLogFileEnabled(config) {
+  return config.logFile?.freshLogFile ?? DEFAULT_RELINKA_CONFIG.logFile?.freshLogFile ?? false;
+}
 function isDevEnv() {
   return process.env.NODE_ENV === "development";
 }
@@ -232,18 +197,27 @@ function getTimestamp(config) {
   return format.replace("YYYY", String(now.getFullYear())).replace("MM", String(now.getMonth() + 1).padStart(2, "0")).replace("DD", String(now.getDate()).padStart(2, "0")).replace("HH", String(now.getHours()).padStart(2, "0")).replace("mm", String(now.getMinutes()).padStart(2, "0")).replace("ss", String(now.getSeconds()).padStart(2, "0")).replace("SSS", String(now.getMilliseconds()).padStart(3, "0"));
 }
 function getLogFilePath(config) {
-  const logDir = getLogDir(config);
-  const daily = isDailyLogsEnabled(config);
-  let finalLogName = getBaseLogName(config);
-  if (daily) {
-    const datePrefix = `${getDateString()}-`;
-    finalLogName = datePrefix + finalLogName;
+  const logFileConfig = config.logFile || DEFAULT_RELINKA_CONFIG.logFile || {};
+  const nameWithDate = logFileConfig.nameWithDate || "disable";
+  const outputPath = getBaseLogName(config);
+  const dir = path.dirname(outputPath);
+  let filename = path.basename(outputPath);
+  if (nameWithDate !== "disable") {
+    const dateString = getDateString();
+    if (nameWithDate === "append-before") {
+      filename = `${dateString}-${filename}`;
+    } else if (nameWithDate === "append-after") {
+      const nameWithoutExt = filename.replace(/\.log$/, "");
+      filename = `${nameWithoutExt}-${dateString}.log`;
+    }
   }
-  if (finalLogName && !finalLogName.endsWith(".log")) {
-    finalLogName += ".log";
+  if (filename && !filename.endsWith(".log")) {
+    filename += ".log";
   }
-  const effectiveLogName = finalLogName || "relinka.log";
-  return path.resolve(process.cwd(), logDir, effectiveLogName);
+  const effectiveFilename = filename || "logs.log";
+  const finalPath = dir === "." ? effectiveFilename : path.join(dir, effectiveFilename);
+  const baseCwd = userTerminalCwd || process.cwd();
+  return path.resolve(baseCwd, finalPath);
 }
 function getLevelStyle(config, level) {
   const allLevels = config.levels || DEFAULT_RELINKA_CONFIG.levels || {};
@@ -305,6 +279,7 @@ const consoleMethodMap = {
   success: console.log,
   verbose: console.log,
   log: console.log,
+  internal: console.log,
   step: console.log,
   box: console.log,
   message: console.log,
@@ -322,16 +297,40 @@ function logToConsole(config, level, formattedMessage) {
   method(`${colorFn(formattedMessage)}\x1B[0m`);
 }
 async function getLogFilesSortedByDate(config) {
-  const logDirectoryPath = path.resolve(process.cwd(), getLogDir(config));
+  const logDirectoryPath = userTerminalCwd || process.cwd();
   try {
-    if (!await fs.pathExists(logDirectoryPath)) {
-      if (ENABLE_DEV_DEBUG) {
-        console.log(`[Dev Debug] Log directory not found: ${logDirectoryPath}`);
+    const files = await fs.readdir(logDirectoryPath);
+    const logFiles = [];
+    for (const file of files) {
+      const filePath = path.join(logDirectoryPath, file);
+      try {
+        const stats = await fs.stat(filePath);
+        if (stats.isFile() && file.endsWith(".log")) {
+          logFiles.push(file);
+        } else if (stats.isDirectory()) {
+          try {
+            const subFiles = await fs.readdir(filePath);
+            for (const subFile of subFiles) {
+              if (subFile.endsWith(".log")) {
+                logFiles.push(path.join(file, subFile));
+              }
+            }
+          } catch (subDirErr) {
+            if (isVerboseEnabled(config)) {
+              console.error(
+                `[Relinka FS Debug] Error reading subdirectory ${filePath}: ${subDirErr instanceof Error ? subDirErr.message : String(subDirErr)}`
+              );
+            }
+          }
+        }
+      } catch (err) {
+        if (isVerboseEnabled(config)) {
+          console.error(
+            `[Relinka FS Debug] Error accessing ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
       }
-      return [];
     }
-    const files = await fs.readdir(logDirectoryPath);
-    const logFiles = files.filter((f) => f.endsWith(".log"));
     if (logFiles.length === 0) return [];
     const fileInfoPromises = logFiles.map(
       async (fileName) => {
@@ -357,7 +356,7 @@ async function getLogFilesSortedByDate(config) {
   } catch (readErr) {
     if (isVerboseEnabled(config)) {
       console.error(
-        `[Relinka FS Error] Failed reading log directory ${logDirectoryPath}: ${readErr instanceof Error ? readErr.message : String(readErr)}`
+        `[Relinka FS Error] Failed reading directory ${logDirectoryPath}: ${readErr instanceof Error ? readErr.message : String(readErr)}`
       );
     }
     return [];
@@ -615,7 +614,7 @@ export async function relinkaAsync(type, message, ...args) {
     console.log();
     return;
   }
-  await relinkaConfig;
+  await relinkaConfig({ supportFreshLogFile: false });
   const levelName = type.toLowerCase();
   if (levelName === "fatal") {
     shouldNeverHappen(message, ...args);
@@ -658,7 +657,7 @@ export function formatBox(text) {
   const bottom = `\u2514${"\u2500".repeat(width)}\u2518`;
   const content = lines.map((line) => {
     const padding = width - line.length;
-    return `\u2502  ${line}${" ".repeat(padding)}\u2502`;
+    return `\u2502  ${line}${" ".repeat(padding - 2)}\u2502`;
   }).join("\n");
   return `${top}
 ${content}

package/bin/mod.d.ts

@@ -1,3 +1,3 @@
 export { message, step, log, logger } from "./alias.js";
-export type { RelinkaSpecialDirsConfig, RelinkaDirsConfig, LogLevelConfig, LogLevelsConfig, LogLevel, RelinkaConfig, LogFileInfo, RelinkaFunction, } from "./impl.js";
-export { relinkaConfig, relinkaShutdown, flushAllLogBuffers, shouldNeverHappen, truncateString, casesHandled, relinka, relinkaAsync, defineConfig, formatBox, } from "./impl.js";
+export type { RelinkaDirsConfig, LogLevelConfig, LogLevelsConfig, LogLevel, RelinkaConfig, LogFileInfo, RelinkaFunction, RelinkaConfigOptions, } from "./setup.js";
+export { loadRelinkaConfig, relinkaConfig, relinkaShutdown, flushAllLogBuffers, shouldNeverHappen, truncateString, casesHandled, relinka, relinkaAsync, defineConfig, formatBox, } from "./impl.js";

package/bin/mod.js

@@ -1,5 +1,6 @@
 export { message, step, log, logger } from "./alias.js";
 export {
+  loadRelinkaConfig,
   relinkaConfig,
   relinkaShutdown,
   flushAllLogBuffers,

package/bin/setup.d.ts

@@ -0,0 +1,144 @@
+import type { DefaultColorKeys } from "@reliverse/relico";
+export declare const ENABLE_DEV_DEBUG = false;
+export declare const EXIT_GUARD: unique symbol;
+/** Configuration for directory-related settings. */
+export type RelinkaDirsConfig = {
+    maxLogFiles?: number;
+};
+/** Configuration for a single log level. */
+export type LogLevelConfig = {
+    /**
+     * Symbol to display for this log level.
+     * @see https://symbl.cc
+     */
+    symbol: string;
+    /**
+     * Fallback symbol to use if Unicode is not supported.
+     */
+    fallbackSymbol: string;
+    /**
+     * Color to use for this log level.
+     */
+    color: DefaultColorKeys;
+    /**
+     * Number of spaces after the symbol/fallback
+     */
+    spacing?: number;
+};
+/** Configuration for all log levels. */
+export type LogLevelsConfig = Partial<Record<LogLevel, LogLevelConfig>>;
+/** Log level types used by the logger. */
+export type LogLevel = "error" | "fatal" | "info" | "success" | "verbose" | "warn" | "log" | "internal" | "null" | "step" | "box" | "message";
+/**
+ * Configuration options for the Relinka logger.
+ * All properties are optional to allow for partial configuration.
+ * Defaults will be applied during initialization.
+ */
+export type RelinkaConfig = {
+    /**
+     * Enables verbose (aka debug) mode for detailed logging.
+     *
+     * `true` here works only for end-users of CLIs/libs when theirs developers
+     * has been awaited for user's config via `@reliverse/relinka`'s `await relinkaConfig;`
+     */
+    verbose?: boolean;
+    /**
+     * Configuration for directory-related settings.
+     * - `maxLogFiles`: The maximum number of log files to keep before cleanup.
+     */
+    dirs?: RelinkaDirsConfig;
+    /**
+     * Disables color output in the console.
+     */
+    disableColors?: boolean;
+    /**
+     * Configuration for log file output.
+     */
+    logFile?: {
+        /**
+         * Path to the log file.
+         */
+        outputPath?: string;
+        /**
+         * How to handle date in the filename.
+         * - `disable`: No date prefix/suffix
+         * - `append-before`: Add date before the filename (e.g., "2024-01-15-log.txt")
+         * - `append-after`: Add date after the filename (e.g., "log-2024-01-15.txt")
+         */
+        nameWithDate?: "disable" | "append-before" | "append-after";
+        /**
+         * If true, clears the log file when relinkaConfig is executed with supportFreshLogFile: true.
+         * This is useful for starting with a clean log file on each run.
+         */
+        freshLogFile?: boolean;
+    };
+    /**
+     * If true, logs will be saved to a file.
+     */
+    saveLogsToFile?: boolean;
+    /**
+     * Configuration for timestamp in log messages.
+     */
+    timestamp?: {
+        /**
+         * If true, timestamps will be added to log messages.
+         */
+        enabled: boolean;
+        /**
+         * The format for timestamps. Default is YYYY-MM-DD HH:mm:ss.SSS
+         */
+        format?: string;
+    };
+    /**
+     * Allows to customize the log levels.
+     */
+    levels?: LogLevelsConfig;
+    /**
+     * Controls how often the log cleanup runs (in milliseconds)
+     * Default: 10000 (10 seconds)
+     */
+    cleanupInterval?: number;
+    /**
+     * Maximum size of the log write buffer before flushing to disk (in bytes)
+     * Default: 4096 (4KB)
+     */
+    bufferSize?: number;
+    /**
+     * Maximum time to hold logs in buffer before flushing to disk (in milliseconds)
+     * Default: 5000 (5 seconds)
+     */
+    maxBufferAge?: number;
+};
+/** Represents information about a log file for cleanup purposes. */
+export type LogFileInfo = {
+    path: string;
+    mtime: number;
+};
+/**
+ * Default configuration object.
+ * `reconf` will merge this with a config file.
+ */
+export declare const DEFAULT_RELINKA_CONFIG: RelinkaConfig;
+/**
+ * Enhanced relinka function type that supports both traditional and method syntax
+ */
+export type RelinkaFunction = {
+    (type: LogLevel | "clear", message: string, ...args: unknown[]): undefined | never;
+    error(message: string, ...args: unknown[]): void;
+    fatal(message: string, ...args: unknown[]): never;
+    info(message: string, ...args: unknown[]): void;
+    success(message: string, ...args: unknown[]): void;
+    verbose(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    log(message: string, ...args: unknown[]): void;
+    internal(message: string, ...args: unknown[]): void;
+    null(message: string, ...args: unknown[]): void;
+    step(message: string, ...args: unknown[]): void;
+    box(message: string, ...args: unknown[]): void;
+    message(message: string, ...args: unknown[]): void;
+    clear(): void;
+};
+/** Options for relinkaConfig */
+export type RelinkaConfigOptions = {
+    supportFreshLogFile?: boolean;
+};