@aipanel/core 1.2.0-beta.0

package/lib/logger-core.cjs

@@ -0,0 +1,177 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_core_exports = {};
+__export(logger_core_exports, {
+  LEVEL_NAMES: () => LEVEL_NAMES,
+  LogLevel: () => LogLevel,
+  configureLogger: () => configureLogger,
+  formatBytes: () => formatBytes,
+  formatContext: () => formatContext,
+  formatDuration: () => formatDuration,
+  formatLogMessage: () => formatLogMessage,
+  formatValue: () => formatValue,
+  generateTraceId: () => generateTraceId,
+  getConfig: () => getConfig,
+  getTimestamp: () => getTimestamp,
+  setVerbose: () => setVerbose
+});
+module.exports = __toCommonJS(logger_core_exports);
+var import_constants = require("./constants.cjs");
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["NONE"] = 4] = "NONE";
+  return LogLevel2;
+})(LogLevel || {});
+const LEVEL_NAMES = {
+  [0 /* DEBUG */]: "DEBUG",
+  [1 /* INFO */]: "INFO",
+  [2 /* WARN */]: "WARN",
+  [3 /* ERROR */]: "ERROR",
+  [4 /* NONE */]: "NONE"
+};
+let traceCounter = 0;
+let globalConfig = {
+  verbose: false,
+  level: 1 /* INFO */,
+  showTimestamp: true,
+  showCaller: true,
+  showTrace: false,
+  indent: "  "
+};
+function getConfig() {
+  return globalConfig;
+}
+function configureLogger(options) {
+  globalConfig = { ...globalConfig, ...options };
+}
+function setVerbose(verbose) {
+  globalConfig.verbose = verbose;
+  globalConfig.level = verbose ? 0 /* DEBUG */ : 1 /* INFO */;
+}
+function getTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const seconds = String(now.getSeconds()).padStart(2, "0");
+  const ms = String(now.getMilliseconds()).padStart(3, "0");
+  return `${hours}:${minutes}:${seconds}.${ms}`;
+}
+function formatValue(value, depth = 0) {
+  if (depth > 3) return "...";
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return depth > 0 ? `"${value}"` : value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value instanceof Error) {
+    return `${value.name}: ${value.message}${value.stack ? `
+${value.stack}` : ""}`;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    if (value.length > 5) {
+      const items2 = value.slice(0, 3).map((v) => formatValue(v, depth + 1));
+      return `[${items2.join(", ")}, ... ${value.length - 3} more items]`;
+    }
+    const items = value.map((v) => formatValue(v, depth + 1));
+    return `[${items.join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return "{}";
+    if (entries.length > 5) {
+      const shown = entries.slice(0, 3).map(([k, v]) => `${k}: ${formatValue(v, depth + 1)}`);
+      return `{${shown.join(", ")}, ... ${entries.length - 3} more keys}`;
+    }
+    const formatted = entries.map(([k, v]) => `${k}: ${formatValue(v, depth + 1)}`);
+    return `{${formatted.join(", ")}}`;
+  }
+  return String(value);
+}
+function formatContext(context) {
+  if (!context || Object.keys(context).length === 0) return "";
+  const parts = [];
+  if (context.module) parts.push(`[${context.module}]`);
+  if (context.operation) parts.push(`(${context.operation})`);
+  if (context.traceId) parts.push(`trace:${context.traceId}`);
+  if (context.duration !== void 0) parts.push(`${context.duration}ms`);
+  const extraKeys = Object.keys(context).filter(
+    (k) => !["module", "operation", "traceId", "duration", "error"].includes(k)
+  );
+  if (extraKeys.length > 0) {
+    const extra = {};
+    extraKeys.forEach((k) => extra[k] = context[k]);
+    parts.push(formatValue(extra));
+  }
+  return parts.join(" ");
+}
+function generateTraceId() {
+  traceCounter++;
+  const timestamp = Date.now().toString(36);
+  const counter = traceCounter.toString(36).padStart(4, "0");
+  return `${timestamp}-${counter}`;
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))}${sizes[i]}`;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(2)}s`;
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.round(ms % 6e4 / 1e3);
+  return `${minutes}m ${seconds}s`;
+}
+function formatLogMessage(level, message, context, ...args) {
+  const parts = [];
+  if (getConfig().showTimestamp) {
+    parts.push(getTimestamp());
+  }
+  parts.push(LEVEL_NAMES[level].padEnd(5));
+  parts.push(import_constants.LOG_PREFIX);
+  const contextStr = formatContext(context);
+  if (contextStr) {
+    parts.push(contextStr);
+  }
+  parts.push(message);
+  const formattedArgs = args.map((a) => formatValue(a)).join(" ");
+  if (formattedArgs) {
+    parts.push(formattedArgs);
+  }
+  return parts.join(" ");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LEVEL_NAMES,
+  LogLevel,
+  configureLogger,
+  formatBytes,
+  formatContext,
+  formatDuration,
+  formatLogMessage,
+  formatValue,
+  generateTraceId,
+  getConfig,
+  getTimestamp,
+  setVerbose
+});

package/lib/logger-core.d.ts

@@ -0,0 +1,37 @@
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    NONE = 4
+}
+export interface LogContext {
+    module?: string;
+    operation?: string;
+    traceId?: string;
+    duration?: number;
+    error?: Error | unknown;
+    [key: string]: unknown;
+}
+export interface LoggerConfig {
+    verbose: boolean;
+    level: LogLevel;
+    showTimestamp: boolean;
+    showCaller: boolean;
+    showTrace: boolean;
+    indent: string;
+}
+export declare const LEVEL_NAMES: Record<LogLevel, string>;
+export declare function getConfig(): LoggerConfig;
+export declare function configureLogger(options: Partial<LoggerConfig>): void;
+export declare function setVerbose(verbose: boolean): void;
+export declare function getTimestamp(): string;
+export declare function formatValue(value: unknown, depth?: number): string;
+export declare function formatContext(context?: LogContext): string;
+export declare function generateTraceId(): string;
+export declare function formatBytes(bytes: number): string;
+export declare function formatDuration(ms: number): string;
+/**
+ * 格式化日志消息
+ */
+export declare function formatLogMessage(level: LogLevel, message: string, context?: LogContext, ...args: unknown[]): string;

package/lib/logger.cjs

@@ -0,0 +1,145 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_exports = {};
+__export(logger_exports, {
+  createLogger: () => createLogger,
+  logger: () => logger
+});
+module.exports = __toCommonJS(logger_exports);
+var import_constants = require("./constants.cjs");
+var import_logger_core = require("./logger-core.cjs");
+const LEVEL_NAMES = {
+  [import_logger_core.LogLevel.DEBUG]: "DEBUG",
+  [import_logger_core.LogLevel.INFO]: "INFO ",
+  [import_logger_core.LogLevel.WARN]: "WARN ",
+  [import_logger_core.LogLevel.ERROR]: "ERROR",
+  [import_logger_core.LogLevel.NONE]: "NONE "
+};
+const C = {
+  dim: "color: #888",
+  bright: "font-weight: bold",
+  red: "color: #cd0000; font-weight: bold",
+  green: "color: #00cd00",
+  yellow: "color: #cdcd00",
+  blue: "color: #0000cd",
+  magenta: "color: #cd00cd",
+  cyan: "color: #00cdcd",
+  reset: ""
+};
+const LEVEL_COLORS = {
+  [import_logger_core.LogLevel.DEBUG]: C.cyan,
+  [import_logger_core.LogLevel.INFO]: C.green,
+  [import_logger_core.LogLevel.WARN]: C.yellow,
+  [import_logger_core.LogLevel.ERROR]: C.red,
+  [import_logger_core.LogLevel.NONE]: C.reset
+};
+function log(level, message, context, ...args) {
+  if (level < (0, import_logger_core.getConfig)().level) return;
+  const segments = [];
+  const styles = [];
+  if ((0, import_logger_core.getConfig)().showTimestamp) {
+    segments.push("%c%s");
+    styles.push(C.dim, (0, import_logger_core.getTimestamp)());
+  }
+  segments.push(`%c${LEVEL_NAMES[level]}`);
+  styles.push(LEVEL_COLORS[level]);
+  segments.push(`%c${import_constants.LOG_PREFIX}`);
+  styles.push(C.bright);
+  const ctxStr = (0, import_logger_core.formatContext)(context);
+  if (ctxStr) {
+    segments.push(`%c${ctxStr}`);
+    styles.push(C.magenta);
+  }
+  const formattedArgs = args.length > 0 ? ` ${args.map((a) => (0, import_logger_core.formatValue)(a)).join(" ")}` : "";
+  segments.push(`%c${message}${formattedArgs}`);
+  styles.push(C.reset);
+  const output = segments.join(" ");
+  if (context?.error) {
+    const err = context.error;
+    if (err instanceof Error) {
+      if (level >= import_logger_core.LogLevel.ERROR && (0, import_logger_core.getConfig)().showTrace && err.stack) {
+        console.error(output, ...styles, `
+${err.stack}`);
+      } else {
+        console.error(output, ...styles, `
+%cError: ${err.message}`, C.red);
+      }
+    } else {
+      console.error(output, ...styles, `
+%cError: ${(0, import_logger_core.formatValue)(err)}`, C.red);
+    }
+    return;
+  }
+  if (level >= import_logger_core.LogLevel.ERROR) {
+    console.error(output, ...styles);
+  } else if (level === import_logger_core.LogLevel.WARN) {
+    console.warn(output, ...styles);
+  } else if (level === import_logger_core.LogLevel.DEBUG) {
+    console.debug(output, ...styles);
+  } else {
+    console.log(output, ...styles);
+  }
+}
+const logger = {
+  debug(message, context, ...args) {
+    log(import_logger_core.LogLevel.DEBUG, message, context, ...args);
+  },
+  info(message, context, ...args) {
+    log(import_logger_core.LogLevel.INFO, message, context, ...args);
+  },
+  warn(message, context, ...args) {
+    log(import_logger_core.LogLevel.WARN, message, context, ...args);
+  },
+  error(message, context, ...args) {
+    log(import_logger_core.LogLevel.ERROR, message, context, ...args);
+  },
+  group(label, context) {
+    if (!(0, import_logger_core.getConfig)().verbose) return;
+    console.group(
+      `%c${import_constants.LOG_PREFIX}%c ${label}`,
+      C.bright,
+      context?.module ? `%c[${context.module}]%c ` : C.reset,
+      ...context?.module ? [C.magenta, C.reset] : []
+    );
+  },
+  groupEnd() {
+    if (!(0, import_logger_core.getConfig)().verbose) return;
+    console.groupEnd();
+  }
+};
+function createLogger(module2) {
+  return {
+    debug(message, context, ...args) {
+      logger.debug(message, { ...context, module: module2 }, ...args);
+    },
+    info(message, context, ...args) {
+      logger.info(message, { ...context, module: module2 }, ...args);
+    },
+    warn(message, context, ...args) {
+      logger.warn(message, { ...context, module: module2 }, ...args);
+    },
+    error(message, context, ...args) {
+      logger.error(message, { ...context, module: module2 }, ...args);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLogger,
+  logger
+});

package/lib/logger.d.ts

@@ -0,0 +1,15 @@
+import { type LogContext } from "./logger-core";
+export declare const logger: {
+    debug(message: string, context?: LogContext, ...args: unknown[]): void;
+    info(message: string, context?: LogContext, ...args: unknown[]): void;
+    warn(message: string, context?: LogContext, ...args: unknown[]): void;
+    error(message: string, context?: LogContext, ...args: unknown[]): void;
+    group(label: string, context?: LogContext): void;
+    groupEnd(): void;
+};
+export declare function createLogger(module: string): {
+    debug(message: string, context?: Omit<LogContext, "module">, ...args: unknown[]): void;
+    info(message: string, context?: Omit<LogContext, "module">, ...args: unknown[]): void;
+    warn(message: string, context?: Omit<LogContext, "module">, ...args: unknown[]): void;
+    error(message: string, context?: Omit<LogContext, "module">, ...args: unknown[]): void;
+};

package/lib/node-logger.cjs

@@ -0,0 +1,252 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var node_logger_exports = {};
+__export(node_logger_exports, {
+  PerformanceTimer: () => PerformanceTimer,
+  RequestContext: () => RequestContext,
+  createLogger: () => createNodeLogger,
+  createNodeLogger: () => createNodeLogger,
+  logMethod: () => logMethod,
+  logger: () => nodeLogger,
+  nodeLogger: () => nodeLogger
+});
+module.exports = __toCommonJS(node_logger_exports);
+var import_constants = require("./constants.cjs");
+var import_logger_core = require("./logger-core.cjs");
+const COLORS = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  bright: "\x1B[1m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m"
+};
+const LEVEL_COLORS = {
+  [import_logger_core.LogLevel.DEBUG]: COLORS.cyan,
+  [import_logger_core.LogLevel.INFO]: COLORS.green,
+  [import_logger_core.LogLevel.WARN]: COLORS.yellow,
+  [import_logger_core.LogLevel.ERROR]: COLORS.red,
+  [import_logger_core.LogLevel.NONE]: COLORS.reset
+};
+const LEVEL_NAMES = {
+  [import_logger_core.LogLevel.DEBUG]: "DEBUG",
+  [import_logger_core.LogLevel.INFO]: "INFO",
+  [import_logger_core.LogLevel.WARN]: "WARN",
+  [import_logger_core.LogLevel.ERROR]: "ERROR",
+  [import_logger_core.LogLevel.NONE]: "NONE"
+};
+function getTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const seconds = String(now.getSeconds()).padStart(2, "0");
+  const ms = String(now.getMilliseconds()).padStart(3, "0");
+  return `${hours}:${minutes}:${seconds}.${ms}`;
+}
+function getCallerInfo(depth = 3) {
+  const stack = new Error().stack;
+  if (!stack) return "";
+  const lines = stack.split("\n");
+  const targetLine = lines[depth];
+  if (!targetLine) return "";
+  const match = targetLine.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/);
+  if (!match) return "";
+  const [, funcName, filePath, line] = match;
+  const fileName = filePath.split("/").pop() || filePath;
+  const func = funcName || "<anonymous>";
+  return `${fileName}:${line} ${func}`;
+}
+function log(level, message, context, ...args) {
+  if (level < (0, import_logger_core.getConfig)().level) return;
+  const parts = [];
+  parts.push(`${COLORS.dim}[${process.pid}]${COLORS.reset}`);
+  if ((0, import_logger_core.getConfig)().showTimestamp) {
+    parts.push(`${COLORS.dim}${getTimestamp()}${COLORS.reset}`);
+  }
+  const levelColor = LEVEL_COLORS[level];
+  const levelName = LEVEL_NAMES[level].padEnd(5);
+  parts.push(`${levelColor}${levelName}${COLORS.reset}`);
+  parts.push(`${COLORS.bright}${import_constants.LOG_PREFIX}${COLORS.reset}`);
+  const contextStr = (0, import_logger_core.formatContext)(context);
+  if (contextStr) {
+    parts.push(`${COLORS.magenta}${contextStr}${COLORS.reset}`);
+  }
+  parts.push(message);
+  if ((0, import_logger_core.getConfig)().showCaller && level >= import_logger_core.LogLevel.WARN) {
+    const caller = getCallerInfo(4);
+    if (caller) {
+      parts.push(`${COLORS.dim}(${caller})${COLORS.reset}`);
+    }
+  }
+  const formattedArgs = args.map((a) => (0, import_logger_core.formatValue)(a)).join(" ");
+  if (formattedArgs) {
+    parts.push(formattedArgs);
+  }
+  if (context?.error) {
+    const err = context.error;
+    if (err instanceof Error) {
+      parts.push(`${COLORS.red}Error: ${err.message}${COLORS.reset}`);
+      if (level >= import_logger_core.LogLevel.ERROR && (0, import_logger_core.getConfig)().showTrace && err.stack) {
+        console.error(`${COLORS.dim}${err.stack}${COLORS.reset}`);
+      }
+    } else {
+      parts.push(`${COLORS.red}Error: ${(0, import_logger_core.formatValue)(err)}${COLORS.reset}`);
+    }
+  }
+  const output = parts.join(" ");
+  if (level >= import_logger_core.LogLevel.ERROR) {
+    console.error(output);
+  } else if (level === import_logger_core.LogLevel.WARN) {
+    console.warn(output);
+  } else {
+    console.log(output);
+  }
+}
+const nodeLogger = {
+  debug(message, context, ...args) {
+    log(import_logger_core.LogLevel.DEBUG, message, context, ...args);
+  },
+  info(message, context, ...args) {
+    log(import_logger_core.LogLevel.INFO, message, context, ...args);
+  },
+  warn(message, context, ...args) {
+    log(import_logger_core.LogLevel.WARN, message, context, ...args);
+  },
+  error(message, context, ...args) {
+    log(import_logger_core.LogLevel.ERROR, message, context, ...args);
+  },
+  group(label, context) {
+    if (!(0, import_logger_core.getConfig)().verbose) return;
+    const contextStr = (0, import_logger_core.formatContext)(context);
+    console.log(
+      `${COLORS.dim}[${process.pid}]${COLORS.reset} ${COLORS.bright}${import_constants.LOG_PREFIX}${COLORS.reset} ${COLORS.blue}\u25BC${COLORS.reset} ${label}${contextStr ? ` ${contextStr}` : ""}`
+    );
+  },
+  groupEnd() {
+    if (!(0, import_logger_core.getConfig)().verbose) return;
+  }
+};
+function createNodeLogger(module2) {
+  return {
+    debug(message, context, ...args) {
+      nodeLogger.debug(message, { ...context, module: module2 }, ...args);
+    },
+    info(message, context, ...args) {
+      nodeLogger.info(message, { ...context, module: module2 }, ...args);
+    },
+    warn(message, context, ...args) {
+      nodeLogger.warn(message, { ...context, module: module2 }, ...args);
+    },
+    error(message, context, ...args) {
+      nodeLogger.error(message, { ...context, module: module2 }, ...args);
+    },
+    timer(operation, context) {
+      return new PerformanceTimer(operation, { ...context, module: module2 });
+    }
+  };
+}
+class PerformanceTimer {
+  constructor(operation, context) {
+    __publicField(this, "startTime");
+    __publicField(this, "context");
+    __publicField(this, "operation");
+    this.operation = operation;
+    this.context = context || {};
+    this.startTime = performance.now();
+    nodeLogger.debug(`\u23F1\uFE0F  Starting: ${operation}`, this.context);
+  }
+  end(message) {
+    const duration = Math.round(performance.now() - this.startTime);
+    const msg = message || `\u2713 Completed: ${this.operation}`;
+    nodeLogger.debug(msg, { ...this.context, duration });
+    return duration;
+  }
+  checkpoint(label) {
+    const elapsed = Math.round(performance.now() - this.startTime);
+    nodeLogger.debug(`  \u21B3 ${label}`, { ...this.context, duration: elapsed });
+    return elapsed;
+  }
+}
+class RequestContext {
+  constructor(method, path) {
+    __publicField(this, "traceId");
+    __publicField(this, "method");
+    __publicField(this, "path");
+    __publicField(this, "startTime");
+    __publicField(this, "checkpoints", []);
+    this.traceId = (0, import_logger_core.generateTraceId)();
+    this.method = method;
+    this.path = path;
+    this.startTime = performance.now();
+    nodeLogger.debug(`\u2192 ${method} ${path}`, { traceId: this.traceId, module: "HTTP" });
+  }
+  checkpoint(label) {
+    const elapsed = Math.round(performance.now() - this.startTime);
+    this.checkpoints.push({ time: elapsed, label });
+    nodeLogger.debug(`  \u2192 ${label}`, { traceId: this.traceId, duration: elapsed });
+  }
+  end(statusCode) {
+    const duration = Math.round(performance.now() - this.startTime);
+    const statusColor = statusCode < 400 ? COLORS.green : COLORS.red;
+    nodeLogger.debug(`\u2190 ${this.method} ${this.path} ${statusColor}${statusCode}${COLORS.reset}`, {
+      traceId: this.traceId,
+      duration,
+      checkpoints: this.checkpoints.length
+    });
+  }
+  error(error) {
+    const duration = Math.round(performance.now() - this.startTime);
+    nodeLogger.error(`\u2717 ${this.method} ${this.path}`, {
+      traceId: this.traceId,
+      duration,
+      error
+    });
+  }
+}
+function logMethod(target, propertyKey, descriptor) {
+  const originalMethod = descriptor.value;
+  const className = target.constructor.name;
+  descriptor.value = async function(...args) {
+    const timer = new PerformanceTimer(`${className}.${propertyKey}`);
+    try {
+      const result = await originalMethod.apply(this, args);
+      timer.end();
+      return result;
+    } catch (error) {
+      timer.end("\u274C Failed");
+      throw error;
+    }
+  };
+  return descriptor;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PerformanceTimer,
+  RequestContext,
+  createLogger,
+  createNodeLogger,
+  logMethod,
+  logger,
+  nodeLogger
+});

package/lib/node-logger.d.ts

@@ -0,0 +1,38 @@
+import { type LogContext } from "./logger-core";
+export declare const nodeLogger: {
+    debug(message: string, context?: LogContext, ...args: unknown[]): void;
+    info(message: string, context?: LogContext, ...args: unknown[]): void;
+    warn(message: string, context?: LogContext, ...args: unknown[]): void;
+    error(message: string, context?: LogContext, ...args: unknown[]): void;
+    group(label: string, context?: LogContext): void;
+    groupEnd(): void;
+};
+export declare function createNodeLogger(module: string): {
+    debug(message: string, context?: Omit<LogContext, "module">, ...args: unknown[]): void;
+    info(message: string, context?: Omit<LogContext, "module">, ...args: unknown[]): void;
+    warn(message: string, context?: Omit<LogContext, "module">, ...args: unknown[]): void;
+    error(message: string, context?: Omit<LogContext, "module">, ...args: unknown[]): void;
+    timer(operation: string, context?: Omit<LogContext, "module">): PerformanceTimer;
+};
+export declare class PerformanceTimer {
+    private startTime;
+    private context;
+    private operation;
+    constructor(operation: string, context?: LogContext);
+    end(message?: string): number;
+    checkpoint(label: string): number;
+}
+export declare class RequestContext {
+    traceId: string;
+    method: string;
+    path: string;
+    startTime: number;
+    private checkpoints;
+    constructor(method: string, path: string);
+    checkpoint(label: string): void;
+    end(statusCode: number): void;
+    error(error: Error | unknown): void;
+}
+export declare function logMethod(target: unknown, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+export { nodeLogger as logger };
+export { createNodeLogger as createLogger };