nolo-cli 0.95.0-alpha.6 → 0.95.0

package/chunk-UNYJU5L6.js

@@ -0,0 +1,780 @@
+// packages/cli/diagnostics/normalizeError.ts
+var MAX_CAUSE_DEPTH = 4;
+var MAX_AGGREGATE_ERRORS = 8;
+var MAX_MESSAGE_LENGTH = 400;
+var MAX_OUTPUT_LENGTH = 2e3;
+var SECRET_PATTERNS = [
+  /\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi,
+  /\b(?:token|secret|password|passwd|apikey|api[_-]?key|authorization|auth)\s*[:=]\s*["']?[^\s"']{6,}/gi,
+  /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*\b/g,
+  // JWT
+  /\b[A-Fa-f0-9]{32,}\b/g,
+  // 长 hex（session key / hash token）
+  /\b(?:sk|pk|ak|xox[baprs]|ghp|gho|ghu|ghs|ghr|glpat|nolo)[-_][A-Za-z0-9_-]{8,}\b/g
+  // 常见 key 前缀
+];
+var PATH_PREFIXES = [];
+function initPathPrefixes() {
+  try {
+    const home = process.env.HOME ?? process.env.USERPROFILE;
+    const noloHome = process.env.NOLO_HOME;
+    if (noloHome && noloHome.length > 4) {
+      PATH_PREFIXES.push(new RegExp(escapeRe(noloHome), "g"));
+    }
+    if (home && home.length > 4) {
+      PATH_PREFIXES.push(new RegExp(escapeRe(home), "g"));
+    }
+  } catch {
+  }
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+initPathPrefixes();
+function sanitizeText(input) {
+  let s;
+  try {
+    s = typeof input === "string" ? input : String(input);
+  } catch {
+    return "[unstringifiable]";
+  }
+  for (const re of SECRET_PATTERNS) {
+    re.lastIndex = 0;
+    s = s.replace(re, (m) => {
+      const sepIdx = m.search(/[:=\s]/);
+      const head = sepIdx >= 0 && sepIdx < 12 ? m.slice(0, sepIdx + 1) : "";
+      return `${head}[redacted]`;
+    });
+  }
+  for (const re of PATH_PREFIXES) {
+    re.lastIndex = 0;
+    s = s.replace(re, "~");
+  }
+  s = s.replace(/[\r\n]+/g, "\u23CE").replace(/[\u0000-\u001f\u007f-\u009f]/g, "");
+  if (s.length > MAX_MESSAGE_LENGTH) {
+    s = `${s.slice(0, MAX_MESSAGE_LENGTH)}\u2026(+${s.length - MAX_MESSAGE_LENGTH}ch)`;
+  }
+  return s;
+}
+function safeGet(obj, key) {
+  try {
+    if (obj === null || obj === void 0) return void 0;
+    return obj[key];
+  } catch {
+    return `[throwing-getter:${key}]`;
+  }
+}
+function safeString(v, maxLen = MAX_MESSAGE_LENGTH) {
+  if (v === void 0 || v === null) return void 0;
+  try {
+    const s = typeof v === "string" ? v : String(v);
+    return s.length > maxLen ? `${s.slice(0, maxLen)}\u2026` : s;
+  } catch {
+    return "[unstringifiable]";
+  }
+}
+function normalizeError(err) {
+  try {
+    if (err === null) return "null";
+    if (err === void 0) return "undefined";
+    const seen = /* @__PURE__ */ new Set();
+    const parts = [];
+    let current2 = err;
+    let depth = 0;
+    while (current2 !== void 0 && current2 !== null && depth < MAX_CAUSE_DEPTH) {
+      if (typeof current2 === "object") {
+        if (seen.has(current2)) {
+          parts.push("[circular-cause]");
+          break;
+        }
+        seen.add(current2);
+      }
+      const { text, cause } = describeOne(current2, seen);
+      parts.push(text);
+      if (cause === void 0) break;
+      current2 = cause;
+      depth += 1;
+    }
+    if (depth >= MAX_CAUSE_DEPTH && current2 !== void 0 && current2 !== null) {
+      parts.push(`[cause-chain-truncated@depth=${MAX_CAUSE_DEPTH}]`);
+    }
+    let out = parts.join(" <-caused by<- ");
+    if (out.length > MAX_OUTPUT_LENGTH) {
+      out = `${out.slice(0, MAX_OUTPUT_LENGTH)}\u2026[truncated]`;
+    }
+    return out || "[empty-error]";
+  } catch (inner) {
+    try {
+      return `[normalizeError-failed: ${String(inner)}]`;
+    } catch {
+      return "[normalizeError-failed]";
+    }
+  }
+}
+function describeOne(v, seen) {
+  if (v === null) return { text: "null", cause: void 0 };
+  if (v === void 0) return { text: "undefined", cause: void 0 };
+  const t = typeof v;
+  if (t === "string") return { text: sanitizeText(v), cause: void 0 };
+  if (t === "number" || t === "boolean" || t === "bigint" || t === "symbol") {
+    return { text: safeString(v) ?? String(t), cause: void 0 };
+  }
+  if (t === "function") {
+    return { text: `[function ${safeString(safeGet(v, "name"), 60) ?? "anonymous"}]`, cause: void 0 };
+  }
+  const name = safeString(safeGet(v, "name"), 80) ?? safeString(safeGet(v, "constructor") && safeGet(safeGet(v, "constructor"), "name"), 80);
+  const message = safeString(safeGet(v, "message"));
+  const code = safeString(safeGet(v, "code"), 60);
+  const status = safeGet(v, "status") ?? safeGet(v, "statusCode");
+  const cause = safeGet(v, "cause");
+  let head;
+  if (name && message) head = `${name}: ${message}`;
+  else if (message) head = message;
+  else if (name) head = name;
+  else head = safeString(v, 160) ?? "[object-error]";
+  head = sanitizeText(head);
+  const extras = [];
+  if (code) extras.push(`code=${sanitizeText(code)}`);
+  if (typeof status === "number") extras.push(`status=${status}`);
+  if (isAggregateErrorLike(v)) {
+    const agg = describeAggregate(v, seen);
+    if (agg) extras.push(agg);
+  }
+  const suffix = extras.length > 0 ? ` (${extras.join(", ")})` : "";
+  return { text: `${head}${suffix}`, cause };
+}
+function isAggregateErrorLike(v) {
+  try {
+    if (v instanceof AggregateError) return true;
+  } catch {
+  }
+  const name = safeGet(v, "name");
+  const errors = safeGet(v, "errors");
+  return name === "AggregateError" && Array.isArray(errors);
+}
+function describeAggregate(v, seen) {
+  const errors = safeGet(v, "errors");
+  if (!Array.isArray(errors)) return void 0;
+  const total = errors.length;
+  const first = [];
+  for (let i = 0; i < Math.min(total, MAX_AGGREGATE_ERRORS); i += 1) {
+    const e = errors[i];
+    if (e !== null && typeof e === "object" && seen.has(e)) {
+      first.push("[circular]");
+      continue;
+    }
+    first.push(describeOne(e, seen).text);
+  }
+  const more = total > MAX_AGGREGATE_ERRORS ? `, +${total - MAX_AGGREGATE_ERRORS} more` : "";
+  return `${total} aggregated [${first.join(" | ")}${more}]`;
+}
+
+// packages/cli/diagnostics/consoleBridge.ts
+var PATCHED_METHODS = [
+  "log",
+  "info",
+  "debug",
+  "trace",
+  "warn",
+  "error",
+  "dir",
+  "table",
+  "group",
+  "groupEnd",
+  "groupCollapsed",
+  "assert",
+  "count",
+  "countReset",
+  "time",
+  "timeEnd",
+  "timeLog",
+  "timeStamp"
+];
+var LEVEL_BY_METHOD = {
+  log: "info",
+  info: "info",
+  debug: "debug",
+  trace: "trace",
+  warn: "warn",
+  error: "error",
+  dir: "info",
+  table: "info",
+  group: "info",
+  groupEnd: "info",
+  groupCollapsed: "info",
+  assert: "warn",
+  count: "debug",
+  countReset: "debug",
+  time: "debug",
+  timeEnd: "debug",
+  timeLog: "debug",
+  timeStamp: "debug"
+};
+var DIAG_MAX_ARG_CHARS = 400;
+function formatArg(a) {
+  if (typeof a === "string") return a;
+  if (a instanceof Error) {
+    try {
+      return `${a.name}: ${a.message}`;
+    } catch {
+      return "[error]";
+    }
+  }
+  try {
+    const j = JSON.stringify(a);
+    if (j === void 0) return String(a);
+    return j.length > DIAG_MAX_ARG_CHARS ? `${j.slice(0, DIAG_MAX_ARG_CHARS)}\u2026` : j;
+  } catch {
+    try {
+      return String(a);
+    } catch {
+      return "[unprintable]";
+    }
+  }
+}
+function installConsoleBridge(opts) {
+  const originals = /* @__PURE__ */ new Map();
+  const originalFns = /* @__PURE__ */ new Map();
+  let installed = true;
+  let inBridge = false;
+  let reentrantDropped = 0;
+  const emit = (level, args) => {
+    if (inBridge) {
+      reentrantDropped += 1;
+      return;
+    }
+    inBridge = true;
+    try {
+      const raw = args.map(formatArg).join(" ");
+      const event = {
+        ts: opts.now?.() ?? Date.now(),
+        level,
+        component: opts.component ?? "console",
+        message: raw
+      };
+      opts.sink.write(event, `[${event.level}] [${event.component}] ${sanitizeText(raw)}`);
+    } catch {
+    } finally {
+      inBridge = false;
+    }
+  };
+  for (const name of PATCHED_METHODS) {
+    try {
+      const desc = Object.getOwnPropertyDescriptor(console, name) ?? {
+        value: console[name],
+        writable: true,
+        configurable: true,
+        enumerable: true
+      };
+      originals.set(name, desc);
+      const origFn = desc.value;
+      if (typeof origFn === "function") {
+        originalFns.set(name, origFn.bind(console));
+      }
+      const level = LEVEL_BY_METHOD[name] ?? "info";
+      const patched = function patchedConsole(...args) {
+        if (name === "assert") {
+          const [assertion, ...rest] = args;
+          if (assertion) return void 0;
+          emit("warn", ["Assertion failed:", ...rest]);
+          return void 0;
+        }
+        if (opts.passthrough && LOG_LEVEL_ORDER_VALUE[level] < LOG_LEVEL_ORDER_VALUE.warn) {
+          const orig = originalFns.get(name);
+          if (orig) {
+            try {
+              orig(...args);
+            } catch {
+            }
+          }
+        }
+        emit(level, args);
+        return void 0;
+      };
+      Object.defineProperty(console, name, {
+        value: patched,
+        writable: true,
+        configurable: true,
+        enumerable: desc.enumerable ?? true
+      });
+    } catch {
+    }
+  }
+  return {
+    get installed() {
+      return installed;
+    },
+    /** 测试/诊断自观测：被重入守卫丢弃的调用数 */
+    get reentrantDropped() {
+      return reentrantDropped;
+    },
+    uninstall() {
+      if (!installed) return;
+      installed = false;
+      for (const name of PATCHED_METHODS) {
+        const orig = originals.get(name);
+        if (!orig) continue;
+        try {
+          Object.defineProperty(console, name, orig);
+        } catch {
+          try {
+            console[name] = orig.value;
+          } catch {
+          }
+        }
+      }
+    }
+  };
+}
+var LOG_LEVEL_ORDER_VALUE = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60
+};
+
+// packages/cli/diagnostics/sinks/ringBuffer.ts
+var RING_BUFFER_CAPACITY = 2e3;
+var RingBufferSink = class {
+  capacity;
+  buf;
+  head = 0;
+  // 下一次写入位置
+  count = 0;
+  constructor(capacity = RING_BUFFER_CAPACITY) {
+    this.capacity = Math.max(1, capacity);
+    this.buf = new Array(this.capacity);
+  }
+  write(event, _line) {
+    try {
+      this.buf[this.head] = event;
+      this.head = (this.head + 1) % this.capacity;
+      if (this.count < this.capacity) this.count += 1;
+    } catch {
+    }
+  }
+  /** 按时间序 dump（最旧 → 最新） */
+  drain() {
+    if (this.count === 0) return [];
+    const out = new Array(this.count);
+    const start = this.count < this.capacity ? 0 : this.head;
+    for (let i = 0; i < this.count; i += 1) {
+      out[i] = this.buf[(start + i) % this.capacity];
+    }
+    return out;
+  }
+  get size() {
+    return this.count;
+  }
+};
+var GLOBAL_KEY = "__nolo_diag_ring__";
+function getProcessRingBuffer() {
+  try {
+    return globalThis[GLOBAL_KEY];
+  } catch {
+    return void 0;
+  }
+}
+function installProcessRingBuffer(sink) {
+  try {
+    globalThis[GLOBAL_KEY] = sink;
+  } catch {
+  }
+  return sink;
+}
+
+// packages/cli/diagnostics/sinks/rotatingFile.ts
+import { openSync, mkdirSync, statSync, renameSync, writeSync, closeSync, constants } from "node:fs";
+import { dirname, join } from "node:path";
+var MAX_FILE_BYTES = 10 * 1024 * 1024;
+var MAX_BACKUPS = 5;
+var RotatingFileSink = class {
+  filePath;
+  maxBytes;
+  maxBackups;
+  fd = null;
+  written = 0;
+  disabled = false;
+  constructor(opts) {
+    this.filePath = opts?.filePath ?? resolveDefaultLogPath(opts?.env ?? process.env);
+    this.maxBytes = opts?.maxBytes ?? MAX_FILE_BYTES;
+    this.maxBackups = opts?.maxBackups ?? MAX_BACKUPS;
+  }
+  write(_event, line) {
+    if (this.disabled) return;
+    try {
+      this.ensureOpen();
+      if (this.fd === null) return;
+      const payload = `${line}
+`;
+      writeSync(this.fd, payload);
+      this.written += Buffer.byteLength(payload);
+      if (this.written >= this.maxBytes) this.rotate();
+    } catch {
+      this.disabled = true;
+      try {
+        if (this.fd !== null) closeSync(this.fd);
+      } catch {
+      }
+      this.fd = null;
+    }
+  }
+  flush() {
+    try {
+      if (this.fd !== null) {
+      }
+    } catch {
+    }
+  }
+  close() {
+    try {
+      if (this.fd !== null) closeSync(this.fd);
+    } catch {
+    }
+    this.fd = null;
+  }
+  ensureOpen() {
+    if (this.fd !== null) return;
+    mkdirSync(dirname(this.filePath), { recursive: true, mode: 448 });
+    this.fd = openSync(this.filePath, constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND, 384);
+    try {
+      const st = statSync(this.filePath);
+      this.written = st.size;
+    } catch {
+      this.written = 0;
+    }
+  }
+  rotate() {
+    try {
+      if (this.fd !== null) {
+        closeSync(this.fd);
+        this.fd = null;
+      }
+      for (let i = this.maxBackups - 1; i >= 1; i -= 1) {
+        try {
+          renameSync(`${this.filePath}.${i}`, `${this.filePath}.${i + 1}`);
+        } catch {
+        }
+      }
+      try {
+        renameSync(this.filePath, `${this.filePath}.1`);
+      } catch {
+      }
+      this.written = 0;
+      this.ensureOpen();
+    } catch {
+      this.disabled = true;
+    }
+  }
+};
+function resolveDefaultLogPath(env) {
+  const noloHome = env.NOLO_HOME;
+  if (noloHome) return join(noloHome, "logs", "tui-diag.log");
+  const home = env.HOME ?? env.USERPROFILE ?? ".";
+  return join(home, ".nolo", "logs", "tui-diag.log");
+}
+
+// packages/cli/diagnostics/sinks/stderr.ts
+var StderrSink = class {
+  writer;
+  constructor(writer) {
+    if (writer) {
+      this.writer = writer;
+    } else {
+      const bound = process.stderr.write.bind(process.stderr);
+      this.writer = (t) => {
+        try {
+          bound(t);
+        } catch {
+        }
+      };
+    }
+  }
+  write(_event, line) {
+    try {
+      this.writer(`${line}
+`);
+    } catch {
+    }
+  }
+};
+
+// packages/cli/diagnostics/types.ts
+var LOG_LEVEL_ORDER = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60
+};
+
+// packages/cli/diagnostics/index.ts
+function detectMode(args, env) {
+  const cmd = args[0];
+  const isTuiCommand = cmd === "chat" || cmd === "tui";
+  const tuiModeFlag = args[1] === "--local" || args[1] === "--server" || args[1] === "--auto";
+  const wantsTui = args.length === 0 && !!process.stdin.isTTY || isTuiCommand && args.length === 1 || isTuiCommand && args.length === 2 && tuiModeFlag;
+  if (wantsTui) return "tui";
+  if (env.CI === "true" || env.CI === "1" || env.NOLO_CI === "1" || env.NOLO_CI === "true") {
+    return "ci";
+  }
+  return "agent";
+}
+var noopSink = { write() {
+} };
+var FanoutSink = class {
+  constructor(sinks) {
+    this.sinks = sinks;
+  }
+  write(event, line) {
+    for (const s of this.sinks) {
+      try {
+        s.write(event, line);
+      } catch {
+      }
+    }
+  }
+  flush() {
+    for (const s of this.sinks) {
+      try {
+        s.flush?.();
+      } catch {
+      }
+    }
+  }
+  close() {
+    for (const s of this.sinks) {
+      try {
+        s.close?.();
+      } catch {
+      }
+    }
+  }
+};
+var LevelGatedSink = class {
+  constructor(inner, min, maxExclusive) {
+    this.inner = inner;
+    this.min = min;
+    this.maxExclusive = maxExclusive;
+  }
+  write(event, line) {
+    const v = LOG_LEVEL_ORDER[event.level] ?? 0;
+    if (v < LOG_LEVEL_ORDER[this.min]) return;
+    if (this.maxExclusive && v >= LOG_LEVEL_ORDER[this.maxExclusive]) return;
+    this.inner.write(event, line);
+  }
+  flush() {
+    this.inner.flush?.();
+  }
+  close() {
+    this.inner.close?.();
+  }
+};
+function formatHumanLine(e) {
+  const ts = new Date(e.ts).toISOString();
+  const errPart = e.error ? ` err=${e.error}` : "";
+  const fp = e.fingerprint ? ` fp=${e.fingerprint}` : "";
+  const fieldsPart = e.fields && Object.keys(e.fields).length > 0 ? ` ${sanitizeText(JSON.stringify(e.fields))}` : "";
+  return `${ts} [${e.level}] [${e.component}] ${sanitizeText(e.message)}${errPart}${fp}${fieldsPart}`;
+}
+function formatJsonLine(e) {
+  try {
+    return sanitizeText(JSON.stringify({ ...e, message: sanitizeText(e.message) }));
+  } catch {
+    return `{"level":"${e.level}","component":"${e.component}","message":"${sanitizeText(e.message)}"}`;
+  }
+}
+var FormattingSink = class {
+  constructor(inner, format) {
+    this.inner = inner;
+    this.format = format;
+  }
+  write(event) {
+    let line;
+    try {
+      line = this.format(event);
+    } catch {
+      line = `[${event.level}] [${event.component}] ${sanitizeText(event.message)}`;
+    }
+    this.inner.write(event, line);
+  }
+  flush() {
+    this.inner.flush?.();
+  }
+  close() {
+    this.inner.close?.();
+  }
+};
+function extractError(args) {
+  const last = args[args.length - 1];
+  if (last instanceof Error) {
+    return { error: normalizeError(last), rest: args.slice(0, -1) };
+  }
+  if (args.some((a) => a instanceof Error)) {
+    const rest = args.map((a) => a instanceof Error ? normalizeError(a) : a);
+    return { rest };
+  }
+  return { rest: args };
+}
+function formatMsgArg(a) {
+  if (typeof a === "string") return a;
+  if (a instanceof Error) return normalizeError(a);
+  try {
+    const j = JSON.stringify(a);
+    if (j === void 0) return String(a);
+    return j;
+  } catch {
+    try {
+      return String(a);
+    } catch {
+      return "[unprintable]";
+    }
+  }
+}
+var DiagLogger = class _DiagLogger {
+  constructor(sink, component, fields = {}) {
+    this.sink = sink;
+    this.component = component;
+    this.fields = fields;
+  }
+  emit(level, msg, args) {
+    try {
+      const { error, rest } = extractError(args);
+      const extra = rest.map(formatMsgArg).join(" ");
+      const message = extra ? `${msg} ${extra}` : msg;
+      const fields = Object.keys(this.fields).length > 0 ? { ...this.fields } : void 0;
+      const event = {
+        ts: Date.now(),
+        level,
+        component: this.component,
+        message,
+        ...error ? { error } : {},
+        ...fields ? { fields } : {}
+      };
+      this.sink.write(event, "");
+    } catch {
+    }
+  }
+  trace(m, ...a) {
+    this.emit("trace", m, a);
+  }
+  debug(m, ...a) {
+    this.emit("debug", m, a);
+  }
+  info(m, ...a) {
+    this.emit("info", m, a);
+  }
+  warn(m, ...a) {
+    this.emit("warn", m, a);
+  }
+  error(m, ...a) {
+    this.emit("error", m, a);
+  }
+  fatal(m, ...a) {
+    this.emit("fatal", m, a);
+  }
+  child(bindings) {
+    return new _DiagLogger(
+      this.sink,
+      bindings.component ?? this.component,
+      { ...this.fields, ...bindings.fields ?? {} }
+    );
+  }
+};
+var current = null;
+function initializeDiagnostics(mode, env = process.env) {
+  if (current) return current;
+  let ring = null;
+  const sharedSinks = [];
+  try {
+    ring = installProcessRingBuffer(new RingBufferSink());
+    sharedSinks.push(new FormattingSink(ring, formatHumanLine));
+  } catch {
+  }
+  try {
+    sharedSinks.push(new FormattingSink(new RotatingFileSink({ env }), formatHumanLine));
+  } catch {
+  }
+  const diagSinks = [...sharedSinks];
+  const consoleSinks = [...sharedSinks];
+  if (mode !== "tui") {
+    try {
+      const stderrWriter = process.stderr.write.bind(process.stderr);
+      const useJson = env.NOLO_LOG_FORMAT === "json";
+      const fmt = useJson ? formatJsonLine : formatHumanLine;
+      const stderrRaw = new StderrSink((t) => {
+        try {
+          stderrWriter(t);
+        } catch {
+        }
+      });
+      diagSinks.push(new FormattingSink(stderrRaw, fmt));
+      consoleSinks.push(new LevelGatedSink(new FormattingSink(stderrRaw, fmt), "warn"));
+    } catch {
+    }
+  }
+  const diagSink = new FanoutSink(diagSinks.length > 0 ? diagSinks : [noopSink]);
+  const consoleSink = new FanoutSink(consoleSinks.length > 0 ? consoleSinks : [noopSink]);
+  let bridge;
+  try {
+    bridge = installConsoleBridge({
+      sink: consoleSink,
+      component: "console",
+      // 非 TUI：< warn 调原始 console 方法直通 stdout，保 CLI 输出契约
+      // （大 JSON 不截断、%s 占位符生效）；诊断侧仍记 ring/file。
+      passthrough: mode !== "tui"
+    });
+  } catch {
+    bridge = { uninstall() {
+    }, installed: false };
+  }
+  const logger = new DiagLogger(diagSink, "cli");
+  current = {
+    logger,
+    ringBuffer: ring ?? new RingBufferSink(),
+    bridge,
+    mode,
+    shutdown() {
+      try {
+        bridge.uninstall();
+      } catch {
+      }
+      try {
+        diagSink.close();
+      } catch {
+      }
+      try {
+        consoleSink.close();
+      } catch {
+      }
+      current = null;
+    }
+  };
+  return current;
+}
+function getLogger(component) {
+  if (current) return current.logger.child({ component });
+  const bound = process.stderr.write.bind(process.stderr);
+  const fallbackSink = {
+    write(e, line) {
+      try {
+        bound(line || `[${e.level}] [${e.component}] ${sanitizeText(e.message)}`);
+        bound("\n");
+      } catch {
+      }
+    }
+  };
+  return new DiagLogger(fallbackSink, component);
+}
+
+export {
+  normalizeError,
+  getProcessRingBuffer,
+  resolveDefaultLogPath,
+  detectMode,
+  initializeDiagnostics,
+  getLogger
+};