@nmakarov/cli-toolkit 0.4.0 → 0.5.0

package/dist/index.js

@@ -2896,6 +2896,288 @@ var Db = class {
     return this.isConnected && this.knexInstance !== null;
   }
 };
+
+// src/logger/index.ts
+import chalk from "chalk";
+import util from "util";
+
+// src/logger/transports.ts
+var ConsoleTransport = class {
+  write(payload) {
+    console.info(payload);
+  }
+};
+var ParentProcessTransport = class {
+  write(payload) {
+    if (process.env.VITEST || process.env.NODE_ENV === "test") {
+      console.info(payload);
+      return;
+    }
+    if (typeof process.send === "function" && process.connected === true) {
+      process.send(payload);
+    } else {
+      console.info(payload);
+    }
+  }
+};
+
+// src/logger/index.ts
+var ALL_LEVELS = [
+  "silly",
+  "debug",
+  "logic",
+  "info",
+  "notice",
+  "warn",
+  "error",
+  "results",
+  "request",
+  "response",
+  "progress"
+];
+var LEVEL_COLORS = {
+  error: chalk.red.bold,
+  warn: chalk.rgb(255, 165, 0),
+  notice: chalk.cyan,
+  info: chalk.white.bold,
+  logic: chalk.gray,
+  debug: chalk.gray,
+  silly: chalk.gray,
+  request: chalk.green,
+  response: chalk.yellow,
+  progress: chalk.green,
+  results: chalk.magenta
+};
+var CliToolkitLogger = class {
+  options;
+  transport;
+  startTimes = {};
+  lastProgressTimes = {};
+  constructor(options = {}) {
+    this.options = this.normalizeOptions(options);
+    this.transport = this.options.route === "ipc" ? new ParentProcessTransport() : new ConsoleTransport();
+  }
+  setMode(mode) {
+    if (!this.isValidMode(mode)) {
+      throw new Error(`Unsupported logger mode: ${mode}`);
+    }
+    this.options.mode = mode;
+  }
+  debug(message, ...chunks) {
+    this.out({ level: "debug", message, chunks });
+  }
+  info(message, ...chunks) {
+    this.out({ level: "info", message, chunks });
+  }
+  notice(message, ...chunks) {
+    this.out({ level: "notice", message, chunks });
+  }
+  warn(message, ...chunks) {
+    this.out({ level: "warn", message, chunks });
+  }
+  error(message, ...chunks) {
+    this.out({ level: "error", message, chunks });
+  }
+  logic(message, ...chunks) {
+    this.out({ level: "logic", message, chunks });
+  }
+  silly(message, ...chunks) {
+    this.out({ level: "silly", message, chunks });
+  }
+  results(results) {
+    this.out({ level: "results", message: "results", results });
+  }
+  request(operation, ...chunks) {
+    const message = this.inspectChunks([operation, ...chunks]);
+    this.out({ level: "request", message });
+  }
+  response(operation, ...chunks) {
+    const message = this.inspectChunks([operation, ...chunks]);
+    this.out({ level: "response", message });
+  }
+  progress(message, opts) {
+    const { prefix, count, total } = opts;
+    const paddedTotal = String(total).length;
+    const paddedCount = String(count).padStart(paddedTotal, " ");
+    const payload = {
+      level: "progress",
+      message,
+      count: paddedCount,
+      total,
+      prefix
+    };
+    if (!this.startTimes[prefix ?? ""]) {
+      this.startTimes[prefix ?? ""] = Date.now();
+    }
+    if (this.options.progressTimes) {
+      const elapsedSeconds = (Date.now() - this.startTimes[prefix ?? ""]) / 1e3;
+      let remaining = -1;
+      if (count > 1) {
+        const rate = elapsedSeconds / (count - 1);
+        remaining = (total - count) * rate;
+      }
+      payload.elapsed = this.round(elapsedSeconds, 2);
+      payload.remaining = remaining >= 0 ? this.round(remaining, 2) : remaining;
+    }
+    if (count >= total) {
+      delete this.startTimes[prefix ?? ""];
+      delete this.lastProgressTimes[prefix ?? ""];
+    }
+    if (this.shouldOutputProgress(prefix ?? "", count, total)) {
+      this.out(payload);
+      if (this.options.progressThrottle && prefix) {
+        this.lastProgressTimes[prefix] = Date.now();
+      }
+    }
+  }
+  shouldOutputProgress(prefix, count, total) {
+    if (!this.options.progressThrottle) {
+      return true;
+    }
+    if (count === 1 || count === total || !prefix) {
+      return true;
+    }
+    const lastTime = this.lastProgressTimes[prefix];
+    if (!lastTime) {
+      return true;
+    }
+    return Date.now() - lastTime >= this.options.progressThrottle;
+  }
+  out(struct) {
+    if (this.options.silent) {
+      return;
+    }
+    if (!this.options.levels.includes(struct.level)) {
+      return;
+    }
+    if (this.options.prefix && !struct.prefix) {
+      struct.prefix = this.options.prefix;
+    }
+    const output = this.options.mode === "json" ? struct : this.formatLog(struct);
+    this.transport.write(output);
+  }
+  formatLog(struct) {
+    const parts = [];
+    const now = /* @__PURE__ */ new Date();
+    if (this.options.timestamp) {
+      parts.push(now.toISOString());
+    }
+    if (this.options.showLevel) {
+      parts.push(struct.level.toUpperCase());
+    }
+    if (struct.level === "progress") {
+      if (struct.prefix) {
+        parts.push(LEVEL_COLORS[struct.level].bold(struct.prefix));
+      }
+      if (struct.count !== void 0 && struct.total !== void 0) {
+        parts.push(LEVEL_COLORS[struct.level](`${struct.count}/${struct.total}`));
+      }
+    } else if (struct.prefix) {
+      parts.push(chalk.cyan(`[${struct.prefix}]`));
+    }
+    if (struct.message) {
+      const formatter = LEVEL_COLORS[struct.level] ?? chalk.white;
+      parts.push(formatter.bold(struct.message));
+    }
+    if (struct.level === "progress") {
+      if (struct.elapsed !== void 0 && struct.remaining !== void 0) {
+        const formatter = LEVEL_COLORS[struct.level];
+        parts.push(formatter(`${struct.elapsed}/${struct.remaining}`));
+      }
+    }
+    if (struct.chunks && struct.chunks.length) {
+      parts.push(this.inspectChunks(struct.chunks));
+    }
+    if (struct.results) {
+      const formatter = LEVEL_COLORS[struct.level] ?? chalk.white;
+      parts.push(formatter(JSON.stringify(struct.results, null, 4)));
+    }
+    return parts.join(" ");
+  }
+  inspectChunks(chunks) {
+    return chunks.map((chunk) => util.inspect(chunk, { colors: true, depth: null })).join(" ");
+  }
+  normalizeOptions(options) {
+    const { route, mode, prefix, silent, showLevel, timestamp, levels, progress } = options;
+    const shouldUseIpc = this.shouldUseIpcRoute();
+    const normalized = {
+      mode: this.isValidMode(mode) ? mode : "text",
+      route: route ?? (shouldUseIpc ? "ipc" : "console"),
+      prefix,
+      silent: silent ?? false,
+      showLevel: showLevel ?? true,
+      timestamp: timestamp ?? false,
+      levels: this.normalizeLevels(levels),
+      progressTimes: progress?.withTimes ?? false,
+      progressThrottle: progress?.throttleMs
+    };
+    return normalized;
+  }
+  shouldUseIpcRoute() {
+    if (process.env.VITEST || process.env.NODE_ENV === "test") {
+      return false;
+    }
+    return typeof process.send === "function" && process.connected === true;
+  }
+  normalizeLevels(levels) {
+    if (!levels || !levels.length) {
+      return ALL_LEVELS;
+    }
+    const includes = levels.filter((level) => !level.startsWith("-"));
+    const excludes = levels.filter((level) => level.startsWith("-")).map((level) => level.slice(1));
+    const unknown = [...includes, ...excludes].filter((level) => !ALL_LEVELS.includes(level));
+    if (unknown.length) {
+      console.warn(`[Logger] Unknown level(s): ${unknown.join(", ")}`);
+    }
+    const base = includes.length ? includes : ALL_LEVELS;
+    return base.filter((level) => !excludes.includes(level));
+  }
+  isValidMode(mode) {
+    return mode === void 0 || mode === null || mode === "text" || mode === "json";
+  }
+  round(value, places) {
+    const factor = Math.pow(10, places);
+    return Math.round(value * factor) / factor;
+  }
+};
+
+// src/init/index.ts
+import { EventEmitter } from "events";
+function setup(opts = {}) {
+  const args = new Args({
+    overrides: opts.overrides || {},
+    defaults: opts.defaults || {}
+  });
+  const params = new Params({ args }, opts.overrides || {});
+  const loggerOptions = opts.logger || {};
+  const logger = new CliToolkitLogger({
+    mode: loggerOptions.mode || "text",
+    route: loggerOptions.route || "console",
+    prefix: loggerOptions.prefix,
+    silent: loggerOptions.silent,
+    showLevel: loggerOptions.showLevel,
+    timestamp: loggerOptions.timestamp,
+    levels: loggerOptions.levels
+  });
+  const cleanupFunctions = [];
+  const context = {
+    args,
+    params,
+    logger,
+    emitter: new EventEmitter(),
+    isStop: () => false,
+    // Will be set in init function
+    cleanupFunctions,
+    registerCleanup: (fn) => {
+      cleanupFunctions.push(fn);
+    }
+  };
+  logger.debug("[setup] completed successfully");
+  return context;
+}
+function setupContext(opts = {}) {
+  return setup(opts);
+}
 export {
   Args,
   Db,
@@ -2927,6 +3209,7 @@ export {
   joiEdateType,
   joiStringArrayType,
   organizeFooterMessages,
+  setupContext,
   showListScreen,
   showMenuScreen,
   showMultiColumnListScreen,