@reliverse/relinka 1.3.6 → 1.3.8

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

@@ -0,0 +1,321 @@
+import { re } from "@reliverse/relico";
+import { loadConfig } from "c12";
+import fs from "fs-extra";
+import path from "pathe";
+const DEV_VERBOSE = false;
+const DEFAULT_RELINKA_CONFIG = {
+  debug: false,
+  dirs: {
+    dailyLogs: false,
+    logDir: ".reliverse/logs",
+    maxLogFiles: 0,
+    specialDirs: {
+      distDirNames: ["dist", "dist-jsr", "dist-npm", "dist-libs"],
+      useParentConfigInDist: true
+    }
+  },
+  disableColors: false,
+  logFilePath: "relinka.log",
+  saveLogsToFile: false,
+  withTimestamp: false
+};
+let currentConfig = { ...DEFAULT_RELINKA_CONFIG };
+let isConfigInitialized = false;
+let resolveRelinkaConfig;
+export const relinkaConfig = new Promise((resolve) => {
+  resolveRelinkaConfig = resolve;
+});
+async function initializeConfig() {
+  try {
+    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 = result.config;
+    isConfigInitialized = true;
+    if (DEV_VERBOSE) {
+      console.log(
+        "[Relinka Config Debug] Config file used:",
+        result.configFile
+      );
+      console.log("[Relinka Config Debug] All merged layers:", result.layers);
+      console.log("[Relinka Config Debug] Final configuration:", currentConfig);
+    }
+    if (resolveRelinkaConfig) {
+      resolveRelinkaConfig(currentConfig);
+    }
+  } catch (err) {
+    console.error(
+      `[Relinka Config Error] Failed to load config: ${err instanceof Error ? err.message : String(err)}`
+    );
+    currentConfig = { ...DEFAULT_RELINKA_CONFIG };
+    isConfigInitialized = true;
+    if (resolveRelinkaConfig) {
+      resolveRelinkaConfig(currentConfig);
+    }
+  }
+}
+initializeConfig().catch((err) => {
+  console.error(
+    `[Relinka Config Error] Unhandled error: ${err instanceof Error ? err.message : String(err)}`
+  );
+  if (!isConfigInitialized) {
+    currentConfig = { ...DEFAULT_RELINKA_CONFIG };
+    isConfigInitialized = true;
+    if (resolveRelinkaConfig) {
+      resolveRelinkaConfig(currentConfig);
+    }
+  }
+});
+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")}`;
+}
+function getLogFilePath(config) {
+  const logDir = getLogDir(config);
+  const daily = isDailyLogsEnabled(config);
+  let finalLogName = getBaseLogName(config);
+  if (daily) {
+    const now = /* @__PURE__ */ new Date();
+    const datePrefix = `${now.getFullYear()}-${String(
+      now.getMonth() + 1
+    ).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}-`;
+    finalLogName = datePrefix + finalLogName;
+  }
+  if (finalLogName && !finalLogName.endsWith(".log")) {
+    finalLogName += ".log";
+  }
+  const effectiveLogName = finalLogName || "relinka.log";
+  return path.resolve(process.cwd(), logDir, effectiveLogName);
+}
+function formatLogMessage(config, level, msg, details) {
+  const timestamp = getTimestamp(config);
+  let detailsStr = "";
+  if (details !== void 0) {
+    if (details instanceof Error) {
+      detailsStr = `
+Stack Trace: ${details.stack || details.message}`;
+    } else if (typeof details === "object" && details !== null) {
+      try {
+        detailsStr = ` ${JSON.stringify(details)}`;
+      } catch {
+        detailsStr = " [object Object]";
+      }
+    } else {
+      detailsStr = ` ${String(details)}`;
+    }
+  }
+  const paddedLevel = level.padEnd(7, " ");
+  return timestamp ? `[${timestamp}] ${paddedLevel} ${msg}${detailsStr}` : `${paddedLevel} ${msg}${detailsStr}`;
+}
+function logToConsole(config, level, formattedMessage) {
+  const COLOR_RESET = "\x1B[0m";
+  if (!isColorEnabled(config)) {
+    if (level === "ERROR") {
+      console.error(formattedMessage);
+    } else {
+      console.log(formattedMessage);
+    }
+  } else {
+    switch (level) {
+      case "ERROR":
+        console.error(re.redBright(formattedMessage) + COLOR_RESET);
+        break;
+      case "WARN":
+        console.warn(re.yellowBright(formattedMessage) + COLOR_RESET);
+        break;
+      case "SUCCESS":
+        console.log(re.greenBright(formattedMessage) + COLOR_RESET);
+        break;
+      case "INFO":
+        console.log(re.cyanBright(formattedMessage) + COLOR_RESET);
+        break;
+      default:
+        console.log(re.dim(formattedMessage) + COLOR_RESET);
+    }
+  }
+}
+async function getLogFilesSortedByDate(config) {
+  const logDirectoryPath = path.resolve(process.cwd(), getLogDir(config));
+  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((f) => f.endsWith(".log")).map(async (f) => {
+      const filePath = path.join(logDirectoryPath, f);
+      try {
+        const stats = await fs.stat(filePath);
+        if (stats.isFile()) {
+          return { path: filePath, mtime: stats.mtime.getTime() };
+        }
+        return null;
+      } catch (err) {
+        if (isDebugEnabled(config)) {
+          console.error(
+            `[Relinka FS Debug] Error reading stats for ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        return null;
+      }
+    });
+    const logFiles = (await Promise.all(logFilesPromises)).filter(
+      (f) => Boolean(f)
+    );
+    return logFiles.sort((a, b) => b.mtime - a.mtime);
+  } catch (readErr) {
+    if (isDebugEnabled(config)) {
+      console.error(
+        `[Relinka FS Error] Failed reading log directory ${logDirectoryPath}: ${readErr instanceof Error ? readErr.message : String(readErr)}`
+      );
+    }
+    return [];
+  }
+}
+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)}`
+          );
+        }
+      }
+    })
+  );
+}
+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 (isDebugEnabled(config)) {
+          console.log(
+            `[Relinka Cleanup] Deleted ${filesToDelete.length} old log file(s). Kept ${maxFiles}.`
+          );
+        }
+      }
+    }
+  } catch (err) {
+    if (isDebugEnabled(config)) {
+      console.error(
+        `[Relinka Cleanup Error] Failed during log cleanup: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+}
+async function appendToLogFile(config, absoluteLogFilePath, logMessage) {
+  try {
+    await fs.ensureDir(path.dirname(absoluteLogFilePath));
+    await fs.appendFile(absoluteLogFilePath, `${logMessage}
+`);
+  } catch (err) {
+    if (isDebugEnabled(config)) {
+      console.error(
+        `[Relinka File Error] Failed to write to log file ${absoluteLogFilePath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+}
+export function relinka(type, message, ...args) {
+  if (type === "clear") {
+    console.clear();
+    return;
+  }
+  if (message === "") {
+    console.log();
+    return;
+  }
+  const logLevelLabel = type === "verbose" ? "DEBUG" : type.toUpperCase();
+  if (logLevelLabel === "DEBUG" && !isDebugEnabled(currentConfig)) {
+    return;
+  }
+  const details = args.length > 1 ? args : args[0];
+  const formatted = formatLogMessage(
+    currentConfig,
+    logLevelLabel,
+    message,
+    details
+  );
+  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(currentConfig)) {
+    return;
+  }
+  const details = args.length > 1 ? args : args[0];
+  const formatted = formatLogMessage(
+    currentConfig,
+    logLevelLabel,
+    message,
+    details
+  );
+  logToConsole(currentConfig, logLevelLabel, formatted);
+  if (shouldSaveLogs(currentConfig)) {
+    const absoluteLogFilePath = getLogFilePath(currentConfig);
+    try {
+      await appendToLogFile(currentConfig, absoluteLogFilePath, formatted);
+      await cleanupOldLogFiles(currentConfig);
+    } catch (err) {
+      if (isDebugEnabled(currentConfig)) {
+        console.error(
+          `[Relinka File Async Error] Error during file logging/cleanup: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+}
+export function defineConfig(config) {
+  return config;
+}