@vite-plugin-opencode-assistant/shared 1.0.5

package/lib/constants.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @fileoverview OpenCode 插件常量定义
+ */
+/** ==================== 网络相关 ==================== */
+/** 默认主机名 */
+export declare const DEFAULT_HOSTNAME = "127.0.0.1";
+/** 默认 Web 服务端口 */
+export declare const DEFAULT_WEB_PORT = 4097;
+/** 服务器启动超时时间（毫秒） */
+export declare const SERVER_START_TIMEOUT = 300000;
+/** 服务器检查间隔（毫秒） */
+export declare const SERVER_CHECK_INTERVAL = 100;
+/** ==================== 重试相关 ==================== */
+/** 默认重试次数 */
+export declare const DEFAULT_RETRIES = 5;
+/** 重试延迟（毫秒） */
+export declare const RETRY_DELAY = 500;
+/** ==================== 端口查找 ==================== */
+/** 最大端口尝试次数 */
+export declare const MAX_PORT_TRIES = 10;
+/** ==================== 日志相关 ==================== */
+/** 插件日志前缀 */
+export declare const LOG_PREFIX = "[vite-plugin-opencode]";
+/** OpenCode Web 日志前缀 */
+export declare const WEB_LOG_PREFIX = "[OpenCode Web]";
+/** OpenCode Web 错误日志前缀 */
+export declare const WEB_ERROR_PREFIX = "[OpenCode Web Error]";
+/** ==================== 挂件相关 ==================== */
+/** 挂件脚本路径 */
+export declare const WIDGET_SCRIPT_PATH = "/__opencode_widget__.js";
+/** 配置数据属性名 */
+export declare const CONFIG_DATA_ATTR = "data-opencode-config";
+/** 上下文 API 路径 */
+export declare const CONTEXT_API_PATH = "/__opencode_context__";
+/** 启动 API 路径 */
+export declare const START_API_PATH = "/__opencode_start__";
+/** 会话列表 API 路径 */
+export declare const SESSIONS_API_PATH = "/__opencode_sessions__";
+/** SSE 事件流路径 */
+export declare const SSE_EVENTS_PATH = "/__opencode_events__";
+/** 上下文更新间隔（毫秒） */
+export declare const CONTEXT_UPDATE_INTERVAL = 500;
+/** 服务器同步间隔（毫秒） */
+export declare const SERVER_SYNC_INTERVAL = 2000;
+/** Vue Inspector 检查间隔（毫秒） */
+export declare const INSPECTOR_CHECK_INTERVAL = 500;
+/** 自动打开延迟（毫秒） */
+export declare const AUTO_OPEN_DELAY = 1000;
+/** 通知显示时间（毫秒） */
+export declare const NOTIFICATION_DURATION = 3000;
+/** ==================== 存储相关 ==================== */
+/** 初始化标记 */
+export declare const INIT_MARKER = "__OPENCODE_INITIALIZED__";
+/** 选中元素存储键 */
+export declare const SELECTED_ELEMENTS_KEY = "__opencode_selected_elements__";
+/** ==================== 文本处理 ==================== */
+/** 元素文本最大显示长度 */
+export declare const MAX_TEXT_LENGTH = 100;
+/** 元素上下文标记 */
+export declare const CONTEXT_MARKER = "[\u5143\u7D20\u4E0A\u4E0B\u6587]";
+/** ==================== 默认配置 ==================== */
+/** 默认插件配置 */
+export declare const DEFAULT_CONFIG: {
+    enabled: boolean;
+    webPort: number;
+    hostname: string;
+    position: "bottom-right";
+    theme: "auto";
+    open: boolean;
+    autoReload: boolean;
+    verbose: boolean;
+    hotkey: string;
+    warmupChromeMcp: boolean;
+};

package/lib/constants.js

@@ -0,0 +1,113 @@
+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 constants_exports = {};
+__export(constants_exports, {
+  AUTO_OPEN_DELAY: () => AUTO_OPEN_DELAY,
+  CONFIG_DATA_ATTR: () => CONFIG_DATA_ATTR,
+  CONTEXT_API_PATH: () => CONTEXT_API_PATH,
+  CONTEXT_MARKER: () => CONTEXT_MARKER,
+  CONTEXT_UPDATE_INTERVAL: () => CONTEXT_UPDATE_INTERVAL,
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  DEFAULT_HOSTNAME: () => DEFAULT_HOSTNAME,
+  DEFAULT_RETRIES: () => DEFAULT_RETRIES,
+  DEFAULT_WEB_PORT: () => DEFAULT_WEB_PORT,
+  INIT_MARKER: () => INIT_MARKER,
+  INSPECTOR_CHECK_INTERVAL: () => INSPECTOR_CHECK_INTERVAL,
+  LOG_PREFIX: () => LOG_PREFIX,
+  MAX_PORT_TRIES: () => MAX_PORT_TRIES,
+  MAX_TEXT_LENGTH: () => MAX_TEXT_LENGTH,
+  NOTIFICATION_DURATION: () => NOTIFICATION_DURATION,
+  RETRY_DELAY: () => RETRY_DELAY,
+  SELECTED_ELEMENTS_KEY: () => SELECTED_ELEMENTS_KEY,
+  SERVER_CHECK_INTERVAL: () => SERVER_CHECK_INTERVAL,
+  SERVER_START_TIMEOUT: () => SERVER_START_TIMEOUT,
+  SERVER_SYNC_INTERVAL: () => SERVER_SYNC_INTERVAL,
+  SESSIONS_API_PATH: () => SESSIONS_API_PATH,
+  SSE_EVENTS_PATH: () => SSE_EVENTS_PATH,
+  START_API_PATH: () => START_API_PATH,
+  WEB_ERROR_PREFIX: () => WEB_ERROR_PREFIX,
+  WEB_LOG_PREFIX: () => WEB_LOG_PREFIX,
+  WIDGET_SCRIPT_PATH: () => WIDGET_SCRIPT_PATH
+});
+module.exports = __toCommonJS(constants_exports);
+const DEFAULT_HOSTNAME = "127.0.0.1";
+const DEFAULT_WEB_PORT = 4097;
+const SERVER_START_TIMEOUT = 3e5;
+const SERVER_CHECK_INTERVAL = 100;
+const DEFAULT_RETRIES = 5;
+const RETRY_DELAY = 500;
+const MAX_PORT_TRIES = 10;
+const LOG_PREFIX = "[vite-plugin-opencode]";
+const WEB_LOG_PREFIX = "[OpenCode Web]";
+const WEB_ERROR_PREFIX = "[OpenCode Web Error]";
+const WIDGET_SCRIPT_PATH = "/__opencode_widget__.js";
+const CONFIG_DATA_ATTR = "data-opencode-config";
+const CONTEXT_API_PATH = "/__opencode_context__";
+const START_API_PATH = "/__opencode_start__";
+const SESSIONS_API_PATH = "/__opencode_sessions__";
+const SSE_EVENTS_PATH = "/__opencode_events__";
+const CONTEXT_UPDATE_INTERVAL = 500;
+const SERVER_SYNC_INTERVAL = 2e3;
+const INSPECTOR_CHECK_INTERVAL = 500;
+const AUTO_OPEN_DELAY = 1e3;
+const NOTIFICATION_DURATION = 3e3;
+const INIT_MARKER = "__OPENCODE_INITIALIZED__";
+const SELECTED_ELEMENTS_KEY = "__opencode_selected_elements__";
+const MAX_TEXT_LENGTH = 100;
+const CONTEXT_MARKER = "[\u5143\u7D20\u4E0A\u4E0B\u6587]";
+const DEFAULT_CONFIG = {
+  enabled: true,
+  webPort: DEFAULT_WEB_PORT,
+  hostname: DEFAULT_HOSTNAME,
+  position: "bottom-right",
+  theme: "auto",
+  open: false,
+  autoReload: true,
+  verbose: false,
+  hotkey: "ctrl+k",
+  warmupChromeMcp: true
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUTO_OPEN_DELAY,
+  CONFIG_DATA_ATTR,
+  CONTEXT_API_PATH,
+  CONTEXT_MARKER,
+  CONTEXT_UPDATE_INTERVAL,
+  DEFAULT_CONFIG,
+  DEFAULT_HOSTNAME,
+  DEFAULT_RETRIES,
+  DEFAULT_WEB_PORT,
+  INIT_MARKER,
+  INSPECTOR_CHECK_INTERVAL,
+  LOG_PREFIX,
+  MAX_PORT_TRIES,
+  MAX_TEXT_LENGTH,
+  NOTIFICATION_DURATION,
+  RETRY_DELAY,
+  SELECTED_ELEMENTS_KEY,
+  SERVER_CHECK_INTERVAL,
+  SERVER_START_TIMEOUT,
+  SERVER_SYNC_INTERVAL,
+  SESSIONS_API_PATH,
+  SSE_EVENTS_PATH,
+  START_API_PATH,
+  WEB_ERROR_PREFIX,
+  WEB_LOG_PREFIX,
+  WIDGET_SCRIPT_PATH
+});

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./constants.js";
+export * from "./logger.js";
+export * from "./types.js";

package/lib/index.js

@@ -0,0 +1,25 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lib_exports = {};
+module.exports = __toCommonJS(lib_exports);
+__reExport(lib_exports, require("./constants.js"), module.exports);
+__reExport(lib_exports, require("./logger.js"), module.exports);
+__reExport(lib_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./constants.js"),
+  ...require("./logger.js"),
+  ...require("./types.js")
+});

package/lib/logger.d.ts

@@ -0,0 +1,64 @@
+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;
+}
+interface LoggerConfig {
+    verbose: boolean;
+    level: LogLevel;
+    showTimestamp: boolean;
+    showCaller: boolean;
+    showTrace: boolean;
+    indent: string;
+}
+export declare function configureLogger(options: Partial<LoggerConfig>): void;
+export declare function setVerbose(verbose: boolean): void;
+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 generateTraceId(): string;
+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 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;
+    timer(operation: string, context?: Omit<LogContext, "module">): PerformanceTimer;
+};
+export declare function logMethod(target: unknown, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+export declare function formatBytes(bytes: number): string;
+export declare function formatDuration(ms: number): string;
+export {};

package/lib/logger.js

@@ -0,0 +1,384 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var logger_exports = {};
+__export(logger_exports, {
+  LogLevel: () => LogLevel,
+  PerformanceTimer: () => PerformanceTimer,
+  RequestContext: () => RequestContext,
+  configureLogger: () => configureLogger,
+  createLogger: () => createLogger,
+  formatBytes: () => formatBytes,
+  formatDuration: () => formatDuration,
+  generateTraceId: () => generateTraceId,
+  logMethod: () => logMethod,
+  logger: () => logger,
+  setVerbose: () => setVerbose
+});
+module.exports = __toCommonJS(logger_exports);
+var import_constants = require("./constants.js");
+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 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 = {
+  [0 /* DEBUG */]: COLORS.cyan,
+  [1 /* INFO */]: COLORS.green,
+  [2 /* WARN */]: COLORS.yellow,
+  [3 /* ERROR */]: COLORS.red,
+  [4 /* NONE */]: COLORS.reset
+};
+const LEVEL_NAMES = {
+  [0 /* DEBUG */]: "DEBUG",
+  [1 /* INFO */]: "INFO",
+  [2 /* WARN */]: "WARN",
+  [3 /* ERROR */]: "ERROR",
+  [4 /* NONE */]: "NONE"
+};
+let globalConfig = {
+  verbose: false,
+  level: 1 /* INFO */,
+  showTimestamp: true,
+  showCaller: true,
+  showTrace: false,
+  indent: "  "
+};
+let traceCounter = 0;
+function configureLogger(options) {
+  globalConfig = __spreadValues(__spreadValues({}, 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 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 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 log(level, message, context, ...args) {
+  if (level < globalConfig.level) return;
+  const parts = [];
+  parts.push(`${COLORS.dim}[${process.pid}]${COLORS.reset}`);
+  if (globalConfig.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 = formatContext(context);
+  if (contextStr) {
+    parts.push(`${COLORS.magenta}${contextStr}${COLORS.reset}`);
+  }
+  parts.push(message);
+  if (globalConfig.showCaller && level >= 2 /* WARN */) {
+    const caller = getCallerInfo(4);
+    if (caller) {
+      parts.push(`${COLORS.dim}(${caller})${COLORS.reset}`);
+    }
+  }
+  const formattedArgs = args.map((a) => formatValue(a)).join(" ");
+  if (formattedArgs) {
+    parts.push(formattedArgs);
+  }
+  const output = parts.join(" ");
+  if (level >= 3 /* ERROR */) {
+    console.error(output);
+  } else if (level === 2 /* WARN */) {
+    console.warn(output);
+  } else {
+    console.log(output);
+  }
+  if ((context == null ? void 0 : context.error) && level >= 3 /* ERROR */ && globalConfig.showTrace) {
+    const err = context.error;
+    if (err instanceof Error && err.stack) {
+      console.error(`${COLORS.dim}${err.stack}${COLORS.reset}`);
+    }
+  }
+}
+const logger = {
+  debug(message, context, ...args) {
+    log(0 /* DEBUG */, message, context, ...args);
+  },
+  info(message, context, ...args) {
+    log(1 /* INFO */, message, context, ...args);
+  },
+  warn(message, context, ...args) {
+    log(2 /* WARN */, message, context, ...args);
+  },
+  error(message, context, ...args) {
+    log(3 /* ERROR */, message, context, ...args);
+  },
+  group(label, context) {
+    if (!globalConfig.verbose) return;
+    const contextStr = 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 (!globalConfig.verbose) return;
+  }
+};
+function generateTraceId() {
+  traceCounter++;
+  const timestamp = Date.now().toString(36);
+  const counter = traceCounter.toString(36).padStart(4, "0");
+  return `${timestamp}-${counter}`;
+}
+class PerformanceTimer {
+  constructor(operation, context) {
+    __publicField(this, "startTime");
+    __publicField(this, "context");
+    __publicField(this, "operation");
+    this.operation = operation;
+    this.context = context || {};
+    this.startTime = performance.now();
+    logger.debug(`\u23F1\uFE0F  Starting: ${operation}`, this.context);
+  }
+  end(message) {
+    const duration = Math.round(performance.now() - this.startTime);
+    const msg = message || `\u2713 Completed: ${this.operation}`;
+    logger.debug(msg, __spreadProps(__spreadValues({}, this.context), { duration }));
+    return duration;
+  }
+  checkpoint(label) {
+    const elapsed = Math.round(performance.now() - this.startTime);
+    logger.debug(`  \u21B3 ${label}`, __spreadProps(__spreadValues({}, 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 = generateTraceId();
+    this.method = method;
+    this.path = path;
+    this.startTime = performance.now();
+    logger.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 });
+    logger.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;
+    logger.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);
+    logger.error(`\u2717 ${this.method} ${this.path}`, {
+      traceId: this.traceId,
+      duration,
+      error
+    });
+  }
+}
+function createLogger(module2) {
+  return {
+    debug(message, context, ...args) {
+      logger.debug(message, __spreadProps(__spreadValues({}, context), { module: module2 }), ...args);
+    },
+    info(message, context, ...args) {
+      logger.info(message, __spreadProps(__spreadValues({}, context), { module: module2 }), ...args);
+    },
+    warn(message, context, ...args) {
+      logger.warn(message, __spreadProps(__spreadValues({}, context), { module: module2 }), ...args);
+    },
+    error(message, context, ...args) {
+      logger.error(message, __spreadProps(__spreadValues({}, context), { module: module2 }), ...args);
+    },
+    timer(operation, context) {
+      return new PerformanceTimer(operation, __spreadProps(__spreadValues({}, context), { module: module2 }));
+    }
+  };
+}
+function logMethod(target, propertyKey, descriptor) {
+  const originalMethod = descriptor.value;
+  const className = target.constructor.name;
+  descriptor.value = function(...args) {
+    return __async(this, null, function* () {
+      const timer = new PerformanceTimer(`${className}.${propertyKey}`);
+      try {
+        const result = yield originalMethod.apply(this, args);
+        timer.end();
+        return result;
+      } catch (error) {
+        timer.end("\u274C Failed");
+        throw error;
+      }
+    });
+  };
+  return descriptor;
+}
+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`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LogLevel,
+  PerformanceTimer,
+  RequestContext,
+  configureLogger,
+  createLogger,
+  formatBytes,
+  formatDuration,
+  generateTraceId,
+  logMethod,
+  logger,
+  setVerbose
+});