@kb-labs/shared-cli-ui 1.0.0

package/dist/debug.cjs

@@ -0,0 +1,765 @@
+'use strict';
+
+// src/debug/formatters/ai.ts
+function formatDebugEntryAI(entry) {
+  return JSON.stringify(entry, null, 2);
+}
+function formatDebugEntriesAI(entries) {
+  return JSON.stringify(entries, null, 2);
+}
+function shouldUseAIFormat(format, jsonMode) {
+  if (jsonMode) {
+    return true;
+  }
+  return format === "ai";
+}
+
+// src/colors.ts
+var CSI = "\x1B[";
+var RESET = "\x1B[0m";
+var createColor = (...codes) => (text) => `${CSI}${codes.join(";")}m${text}${RESET}`;
+var accentBlue = "38;5;39";
+var accentViolet = "38;5;99";
+var accentTeal = "38;5;51";
+var accentIndigo = "38;5;63";
+var neutral = 37;
+var neutralMuted = 90;
+var colors = {
+  // Semantic colors
+  success: createColor(32),
+  error: createColor(31),
+  warning: createColor(33),
+  info: createColor(36),
+  // Accent palette (reused across CLI)
+  primary: createColor(accentBlue),
+  accent: createColor(accentViolet),
+  highlight: createColor(accentTeal),
+  secondary: createColor(accentIndigo),
+  emphasis: createColor("38;5;117"),
+  muted: createColor(neutralMuted),
+  foreground: createColor(neutral),
+  // Formatting helpers
+  dim: createColor(2),
+  bold: createColor(1),
+  underline: createColor(4),
+  inverse: createColor(7)
+};
+var symbolCharacters = {
+  success: "OK",
+  error: "ERR",
+  warning: "WARN",
+  info: "\u2139",
+  bullet: "\u2022",
+  clock: "TIME",
+  folder: "DIR",
+  package: "\u203A",
+  pointer: "\u203A",
+  section: "\u2502"
+};
+var symbols = {
+  success: colors.success(symbolCharacters.success),
+  error: colors.error(symbolCharacters.error),
+  warning: colors.warning(symbolCharacters.warning),
+  info: colors.info(symbolCharacters.info),
+  bullet: colors.muted(symbolCharacters.bullet),
+  clock: colors.info(symbolCharacters.clock),
+  folder: colors.primary(symbolCharacters.folder),
+  package: colors.accent(symbolCharacters.package),
+  pointer: colors.primary(symbolCharacters.pointer),
+  section: colors.primary(symbolCharacters.section)
+};
+var isTruthyEnv = (value) => {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized !== "" && normalized !== "0" && normalized !== "false" && normalized !== "off";
+};
+var supportsColor = (() => {
+  if (typeof process === "undefined") {
+    return false;
+  }
+  const forceColor = process.env.FORCE_COLOR;
+  if (isTruthyEnv(process.env.NO_COLOR)) {
+    return false;
+  }
+  if (isTruthyEnv(forceColor)) {
+    return true;
+  }
+  if (!process.stdout) {
+    return false;
+  }
+  if (process.stdout.isTTY === false) {
+    return false;
+  }
+  return true;
+})();
+var passthrough = (fn) => (text) => supportsColor ? fn(text) : text;
+var safeColors = {
+  success: passthrough(colors.success),
+  error: passthrough(colors.error),
+  warning: passthrough(colors.warning),
+  info: passthrough(colors.info),
+  accent: passthrough(colors.accent),
+  primary: passthrough(colors.primary),
+  highlight: passthrough(colors.highlight),
+  secondary: passthrough(colors.secondary),
+  emphasis: passthrough(colors.emphasis),
+  foreground: passthrough(colors.foreground),
+  muted: passthrough(colors.muted),
+  dim: passthrough(colors.dim),
+  bold: passthrough(colors.bold),
+  underline: passthrough(colors.underline),
+  inverse: passthrough(colors.inverse)
+};
+var safeSymbols = {
+  error: supportsColor ? symbols.error : "\u2717",
+  warning: supportsColor ? symbols.warning : "\u26A0"};
+
+// src/debug/formatters/human.ts
+function formatTimestamp(timestamp) {
+  const date = new Date(timestamp);
+  return date.toISOString();
+}
+function formatDuration(duration) {
+  if (duration < 1e3) {
+    return `${duration}ms`;
+  }
+  return `${(duration / 1e3).toFixed(2)}s`;
+}
+function formatDebugEntryHuman(entry, options = {}) {
+  const parts = [];
+  if (options.showTimestamp) {
+    parts.push(safeColors.dim(formatTimestamp(entry.timestamp)));
+  }
+  parts.push(safeColors.bold(`[${entry.namespace}]`));
+  parts.push(entry.message);
+  if (options.showDuration && typeof entry.duration === "number") {
+    parts.push(safeColors.dim(`(${formatDuration(entry.duration)})`));
+  }
+  if (entry.level === "error") {
+    parts.push(safeColors.error(safeSymbols.error));
+  } else if (entry.level === "warn") {
+    parts.push(safeColors.warning(safeSymbols.warning));
+  }
+  return parts.join(" ");
+}
+function formatDebugEntriesHuman(entries, options = {}) {
+  if (entries.length === 0) {
+    return "";
+  }
+  const sorted = [...entries].sort((a, b) => a.timestamp - b.timestamp);
+  const lines = [];
+  if (options.groupBy === "namespace") {
+    const namespaces = /* @__PURE__ */ new Map();
+    for (const entry of sorted) {
+      if (!namespaces.has(entry.namespace)) {
+        namespaces.set(entry.namespace, []);
+      }
+      namespaces.get(entry.namespace).push(entry);
+    }
+    for (const [namespace, namespaceEntries] of namespaces) {
+      lines.push(safeColors.bold(namespace));
+      for (const entry of namespaceEntries) {
+        lines.push(`  ${formatDebugEntryHuman(entry, options)}`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+  }
+  if (options.groupBy === "group") {
+    const groups = /* @__PURE__ */ new Map();
+    for (const entry of sorted) {
+      const groupName = entry.group ?? "default";
+      if (!groups.has(groupName)) {
+        groups.set(groupName, []);
+      }
+      groups.get(groupName).push(entry);
+    }
+    for (const [groupName, groupEntries] of groups) {
+      lines.push(safeColors.bold(groupName));
+      for (const entry of groupEntries) {
+        lines.push(`  ${formatDebugEntryHuman(entry, options)}`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+  }
+  for (const entry of sorted) {
+    lines.push(formatDebugEntryHuman(entry, options));
+  }
+  return lines.join("\n");
+}
+
+// src/debug/utilities.ts
+function toRegex(pattern) {
+  if (!pattern.includes("*")) {
+    return new RegExp(`^${pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "i");
+  }
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`, "i");
+}
+function filterByNamespace(entries, pattern) {
+  const matcher = typeof pattern === "string" ? toRegex(pattern) : pattern;
+  return entries.filter((entry) => matcher.test(entry.namespace));
+}
+function filterByLevel(entries, level) {
+  const allowed = Array.isArray(level) ? new Set(level) : /* @__PURE__ */ new Set([level]);
+  return entries.filter((entry) => allowed.has(entry.level));
+}
+function filterByTimeRange(entries, from, to) {
+  return entries.filter((entry) => {
+    if (from !== void 0 && entry.timestamp < from) {
+      return false;
+    }
+    if (to !== void 0 && entry.timestamp > to) {
+      return false;
+    }
+    return true;
+  });
+}
+function searchInLogs(entries, query) {
+  const lowered = query.toLowerCase();
+  return entries.filter((entry) => {
+    if (entry.message.toLowerCase().includes(lowered)) {
+      return true;
+    }
+    if (entry.namespace.toLowerCase().includes(lowered)) {
+      return true;
+    }
+    if (entry.meta) {
+      const metaString = JSON.stringify(entry.meta).toLowerCase();
+      if (metaString.includes(lowered)) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+function filterDebugEntries(entries, options) {
+  let filtered = [...entries];
+  if (options.namespace) {
+    filtered = filterByNamespace(filtered, options.namespace);
+  }
+  if (options.level) {
+    filtered = filterByLevel(filtered, options.level);
+  }
+  if (options.timeRange) {
+    filtered = filterByTimeRange(filtered, options.timeRange.from, options.timeRange.to);
+  }
+  if (options.search) {
+    filtered = searchInLogs(filtered, options.search);
+  }
+  if (options.traceId) {
+    filtered = filtered.filter((entry) => entry.traceId === options.traceId);
+  }
+  return filtered;
+}
+function groupByNamespace(entries) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!map.has(entry.namespace)) {
+      map.set(entry.namespace, []);
+    }
+    map.get(entry.namespace).push(entry);
+  }
+  return map;
+}
+function groupByGroup(entries) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const group = entry.group ?? "default";
+    if (!map.has(group)) {
+      map.set(group, []);
+    }
+    map.get(group).push(entry);
+  }
+  return map;
+}
+function createDebugTree(entries) {
+  if (entries.length === 0) {
+    return null;
+  }
+  const sorted = [...entries].sort((a, b) => a.timestamp - b.timestamp);
+  const nodes = /* @__PURE__ */ new Map();
+  let root = null;
+  function ensureNode(entry) {
+    if (entry.spanId && nodes.has(entry.spanId)) {
+      return nodes.get(entry.spanId);
+    }
+    const node = { entry, children: [], depth: 0 };
+    if (entry.spanId) {
+      nodes.set(entry.spanId, node);
+    }
+    return node;
+  }
+  for (const entry of sorted) {
+    const node = ensureNode(entry);
+    if (entry.parentSpanId && nodes.has(entry.parentSpanId)) {
+      const parent = nodes.get(entry.parentSpanId);
+      node.depth = parent.depth + 1;
+      parent.children.push(node);
+    } else if (root === null) {
+      root = node;
+    } else {
+      node.depth = root.depth + 1;
+      root.children.push(node);
+    }
+  }
+  return root;
+}
+function exportToJSON(entries, options = {}) {
+  const filtered = options.filter ? filterDebugEntries(entries, options.filter) : entries;
+  if (options.includeMeta === false) {
+    return JSON.stringify(
+      filtered.map(({ meta, ...rest }) => rest),
+      null,
+      2
+    );
+  }
+  return JSON.stringify(filtered, null, 2);
+}
+function exportToChromeFormat(entries, options = {}) {
+  const filtered = options.filter ? filterDebugEntries(entries, options.filter) : entries;
+  const traceEvents = filtered.map((entry) => ({
+    name: entry.message,
+    cat: entry.namespace,
+    ph: entry.level === "error" ? "E" : entry.level === "warn" ? "W" : "X",
+    ts: entry.timestamp * 1e3,
+    dur: (entry.duration ?? 0) * 1e3,
+    pid: 1,
+    tid: entry.spanId ?? entry.namespace,
+    args: entry.meta ?? {}
+  }));
+  return JSON.stringify({ traceEvents }, null, 2);
+}
+function exportToPlainText(entries, options = {}) {
+  const filtered = options.filter ? filterDebugEntries(entries, options.filter) : entries;
+  return formatDebugEntriesHuman(filtered, { groupBy: "namespace", showTimestamp: true, showDuration: true });
+}
+function exportDebugEntries(entries, options) {
+  const format = options.format ?? "json";
+  switch (format) {
+    case "chrome":
+      return exportToChromeFormat(entries, options);
+    case "text":
+      return exportToPlainText(entries, options);
+    case "json":
+    default:
+      return exportToJSON(entries, options);
+  }
+}
+function describeEntriesHuman(entries, options = {}) {
+  const filtered = filterDebugEntries(entries, options);
+  return formatDebugEntriesHuman(filtered, { showTimestamp: true, showDuration: true, groupBy: "namespace" });
+}
+function describeEntriesAI(entries, options = {}) {
+  const filtered = filterDebugEntries(entries, options);
+  return formatDebugEntriesAI(filtered);
+}
+function describeEntriesTimeline(entries, options = {}) {
+  const filtered = filterDebugEntries(entries, options);
+  return formatTimelineWithSummary(filtered);
+}
+
+// src/debug/formatters/timeline.ts
+function formatDuration2(duration) {
+  if (duration < 1e3) {
+    return `${duration}ms`;
+  }
+  return `${(duration / 1e3).toFixed(2)}s`;
+}
+function formatTimelineNode(node, isLast, prefix = "", maxDepth) {
+  const lines = [];
+  const connector = isLast ? "\u2514\u2500" : "\u251C\u2500";
+  const parts = [];
+  parts.push(safeColors.bold(`[${node.entry.namespace}]`));
+  parts.push(node.entry.message);
+  if (typeof node.entry.duration === "number") {
+    parts.push(safeColors.dim(`(${formatDuration2(node.entry.duration)})`));
+  }
+  if (node.entry.level === "error") {
+    parts.push(safeColors.error(safeSymbols.error));
+  } else if (node.entry.level === "warn") {
+    parts.push(safeColors.warning(safeSymbols.warning));
+  }
+  lines.push(`${prefix}${connector} ${parts.join(" ")}`.trimEnd());
+  if (maxDepth !== void 0 && node.depth + 1 >= maxDepth) {
+    return lines;
+  }
+  const childPrefix = prefix + (isLast ? "   " : "\u2502  ");
+  for (let index = 0; index < node.children.length; index++) {
+    const child = node.children[index];
+    if (!child) {
+      continue;
+    }
+    const childIsLast = index === node.children.length - 1;
+    lines.push(...formatTimelineNode(child, childIsLast, childPrefix, maxDepth));
+  }
+  return lines;
+}
+function formatTimeline(entries) {
+  if (entries.length === 0) {
+    return "";
+  }
+  const tree = createDebugTree(entries);
+  if (!tree) {
+    return "";
+  }
+  return formatTimelineNode(tree, true).join("\n");
+}
+function formatTimelineWithSummary(entries) {
+  const timeline = formatTimeline(entries);
+  if (timeline.length === 0) {
+    return "";
+  }
+  const totalDuration = entries.reduce((acc, entry) => acc + (entry.duration ?? 0), 0);
+  const errorCount = entries.filter((entry) => entry.level === "error").length;
+  const warnCount = entries.filter((entry) => entry.level === "warn").length;
+  const summaryParts = [];
+  if (totalDuration > 0) {
+    summaryParts.push(`Total: ${formatDuration2(totalDuration)}`);
+  }
+  if (errorCount > 0) {
+    summaryParts.push(safeColors.error(`${errorCount} errors`));
+  }
+  if (warnCount > 0) {
+    summaryParts.push(safeColors.warning(`${warnCount} warnings`));
+  }
+  if (summaryParts.length === 0) {
+    return timeline;
+  }
+  return `${timeline}
+
+${safeColors.bold("Summary:")} ${summaryParts.join(", ")}`;
+}
+
+// src/format.ts
+var ANSI_PATTERN = /\u001B\[[0-9;]*m/g;
+function stripAnsi(input) {
+  return input.replace(ANSI_PATTERN, "");
+}
+function visibleLength(input) {
+  return stripAnsi(input).length;
+}
+function box(title, content = [], maxWidth) {
+  const lines = content.length > 0 ? content : [""];
+  const titleWidth = visibleLength(title);
+  const terminalWidth = typeof process !== "undefined" && process.stdout?.columns ? process.stdout.columns : 80;
+  const effectiveMaxWidth = Math.min(terminalWidth - 4, 120);
+  const bodyWidth = Math.min(
+    effectiveMaxWidth,
+    Math.max(titleWidth, ...lines.map((line) => visibleLength(line)))
+  );
+  const wrappedLines = [];
+  for (const line of lines) {
+    const lineLength = visibleLength(line);
+    if (lineLength <= bodyWidth) {
+      wrappedLines.push(line);
+    } else {
+      const words = line.split(/(\s+)/);
+      let currentLine = "";
+      for (const word of words) {
+        const testLine = currentLine + word;
+        if (visibleLength(testLine) <= bodyWidth) {
+          currentLine = testLine;
+        } else {
+          if (currentLine) {
+            wrappedLines.push(currentLine.trimEnd());
+          }
+          if (visibleLength(word) > bodyWidth) {
+            wrappedLines.push(truncate(word, bodyWidth));
+            currentLine = "";
+          } else {
+            currentLine = word;
+          }
+        }
+      }
+      if (currentLine) {
+        wrappedLines.push(currentLine.trimEnd());
+      }
+    }
+  }
+  const topBorder = `\u250C${"\u2500".repeat(bodyWidth + 2)}\u2510`;
+  const titleLine = `\u2502 ${safeColors.bold(title)}${" ".repeat(Math.max(0, bodyWidth - titleWidth))} \u2502`;
+  const bodyLines = wrappedLines.map((line) => {
+    const padding = Math.max(0, bodyWidth - visibleLength(line));
+    return `\u2502 ${line}${" ".repeat(padding)} \u2502`;
+  });
+  const bottomBorder = `\u2514${"\u2500".repeat(bodyWidth + 2)}\u2518`;
+  return [topBorder, titleLine, ...bodyLines, bottomBorder].join("\n");
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.substring(0, maxLength - 3) + "...";
+}
+
+// src/debug/components/output.ts
+function formatDebugOutput(entry, options = {}) {
+  if (shouldUseAIFormat(options.format)) {
+    return formatDebugEntryAI(entry);
+  }
+  return formatDebugEntryHuman(entry, options);
+}
+function formatDebugOutputs(entries, options = {}) {
+  if (shouldUseAIFormat(options.format)) {
+    return formatDebugEntriesAI(entries);
+  }
+  if (options.useTimeline) {
+    return formatTimelineWithSummary(entries);
+  }
+  return formatDebugEntriesHuman(entries, options);
+}
+var DebugSection = class {
+  entries = [];
+  title;
+  options;
+  constructor(title, options = {}) {
+    this.title = title;
+    this.options = options;
+  }
+  add(entry) {
+    this.entries.push(entry);
+  }
+  addAll(entries) {
+    this.entries.push(...entries);
+  }
+  clear() {
+    this.entries.length = 0;
+  }
+  format() {
+    if (this.entries.length === 0) {
+      return "";
+    }
+    const content = formatDebugOutputs(this.entries, this.options);
+    if (!content) {
+      return "";
+    }
+    if (shouldUseAIFormat(this.options.format)) {
+      return content;
+    }
+    return box(this.title, content.split("\n"));
+  }
+  get count() {
+    return this.entries.length;
+  }
+};
+var DebugOutput = class {
+  sections = /* @__PURE__ */ new Map();
+  globalEntries = [];
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  add(entry) {
+    this.globalEntries.push(entry);
+  }
+  addToSection(sectionName, entry) {
+    if (!this.sections.has(sectionName)) {
+      this.sections.set(sectionName, new DebugSection(sectionName, this.options));
+    }
+    this.sections.get(sectionName).add(entry);
+  }
+  getSection(sectionName) {
+    if (!this.sections.has(sectionName)) {
+      this.sections.set(sectionName, new DebugSection(sectionName, this.options));
+    }
+    return this.sections.get(sectionName);
+  }
+  format() {
+    const parts = [];
+    if (this.globalEntries.length > 0) {
+      const formatted = formatDebugOutputs(this.globalEntries, this.options);
+      if (formatted) {
+        parts.push(formatted);
+      }
+    }
+    for (const [, section] of this.sections) {
+      const formatted = section.format();
+      if (formatted) {
+        parts.push(formatted);
+      }
+    }
+    return parts.join("\n\n");
+  }
+  clear() {
+    this.globalEntries.length = 0;
+    this.sections.clear();
+  }
+  get totalCount() {
+    let count = this.globalEntries.length;
+    for (const section of this.sections.values()) {
+      count += section.count;
+    }
+    return count;
+  }
+};
+
+// src/debug/components/tree.ts
+var DebugTree = class {
+  tree = null;
+  options;
+  constructor(entries, options = {}) {
+    this.options = options;
+    this.tree = createDebugTree(entries);
+  }
+  update(entries) {
+    this.tree = createDebugTree(entries);
+  }
+  format() {
+    if (!this.tree) {
+      return "";
+    }
+    const lines = formatTimelineNode(this.tree, true, "", this.options.maxDepth);
+    if (this.options.showSummary) {
+      const summary = this.getSummary();
+      if (summary) {
+        lines.push("", summary);
+      }
+    }
+    return lines.join("\n");
+  }
+  getSummary() {
+    if (!this.tree) {
+      return "";
+    }
+    const stats = this.collectStats(this.tree);
+    const parts = [];
+    if (stats.totalDuration > 0) {
+      parts.push(`total ${stats.totalDuration}ms`);
+    }
+    if (stats.errorCount > 0) {
+      parts.push(`${stats.errorCount} errors`);
+    }
+    if (stats.warnCount > 0) {
+      parts.push(`${stats.warnCount} warnings`);
+    }
+    parts.push(`${stats.nodeCount} nodes`);
+    return `Summary: ${parts.join(", ")}`;
+  }
+  collectStats(node) {
+    let totalDuration = node.entry.duration ?? 0;
+    let errorCount = node.entry.level === "error" ? 1 : 0;
+    let warnCount = node.entry.level === "warn" ? 1 : 0;
+    let nodeCount = 1;
+    for (const child of node.children) {
+      const childStats = this.collectStats(child);
+      totalDuration += childStats.totalDuration;
+      errorCount += childStats.errorCount;
+      warnCount += childStats.warnCount;
+      nodeCount += childStats.nodeCount;
+    }
+    return { totalDuration, errorCount, warnCount, nodeCount };
+  }
+  get root() {
+    return this.tree;
+  }
+};
+
+// src/debug/components/trace.ts
+var DebugTrace = class {
+  entries = [];
+  options;
+  constructor(entries = [], options = {}) {
+    this.entries.push(...entries);
+    this.options = options;
+  }
+  add(entry) {
+    this.entries.push(entry);
+  }
+  addAll(entries) {
+    this.entries.push(...entries);
+  }
+  clear() {
+    this.entries.length = 0;
+  }
+  format() {
+    if (this.entries.length === 0) {
+      return "";
+    }
+    const sorted = [...this.entries].sort((a, b) => a.timestamp - b.timestamp);
+    if (this.options.groupByPlugin) {
+      return this.formatGrouped(sorted);
+    }
+    return formatTimelineWithSummary(sorted);
+  }
+  formatGrouped(entries) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const plugin = entry.namespace.split(":")[0] ?? entry.namespace;
+      if (!groups.has(plugin)) {
+        groups.set(plugin, []);
+      }
+      groups.get(plugin).push(entry);
+    }
+    const parts = [];
+    for (const [plugin, pluginEntries] of groups) {
+      const tree = new DebugTree(pluginEntries, {
+        showSummary: this.options.showSummary,
+        maxDepth: this.options.maxDepth
+      });
+      const formatted = tree.format();
+      if (formatted) {
+        parts.push(`[${plugin}]`, formatted);
+      }
+    }
+    return parts.join("\n\n");
+  }
+  getStats() {
+    const plugins = /* @__PURE__ */ new Set();
+    let totalDuration = 0;
+    let errorCount = 0;
+    let warnCount = 0;
+    for (const entry of this.entries) {
+      const plugin = entry.namespace.split(":")[0] ?? entry.namespace;
+      plugins.add(plugin);
+      totalDuration += entry.duration ?? 0;
+      if (entry.level === "error") {
+        errorCount += 1;
+      } else if (entry.level === "warn") {
+        warnCount += 1;
+      }
+    }
+    return {
+      totalEntries: this.entries.length,
+      plugins: Array.from(plugins),
+      totalDuration,
+      errorCount,
+      warnCount
+    };
+  }
+};
+
+exports.DebugOutput = DebugOutput;
+exports.DebugSection = DebugSection;
+exports.DebugTrace = DebugTrace;
+exports.DebugTree = DebugTree;
+exports.createDebugTree = createDebugTree;
+exports.describeEntriesAI = describeEntriesAI;
+exports.describeEntriesHuman = describeEntriesHuman;
+exports.describeEntriesTimeline = describeEntriesTimeline;
+exports.exportDebugEntries = exportDebugEntries;
+exports.exportToChromeFormat = exportToChromeFormat;
+exports.exportToJSON = exportToJSON;
+exports.exportToPlainText = exportToPlainText;
+exports.filterByLevel = filterByLevel;
+exports.filterByNamespace = filterByNamespace;
+exports.filterByTimeRange = filterByTimeRange;
+exports.filterDebugEntries = filterDebugEntries;
+exports.formatDebugEntriesAI = formatDebugEntriesAI;
+exports.formatDebugEntriesHuman = formatDebugEntriesHuman;
+exports.formatDebugEntryAI = formatDebugEntryAI;
+exports.formatDebugEntryHuman = formatDebugEntryHuman;
+exports.formatDebugOutput = formatDebugOutput;
+exports.formatDebugOutputs = formatDebugOutputs;
+exports.formatTimeline = formatTimeline;
+exports.formatTimelineNode = formatTimelineNode;
+exports.formatTimelineWithSummary = formatTimelineWithSummary;
+exports.groupByGroup = groupByGroup;
+exports.groupByNamespace = groupByNamespace;
+exports.searchInLogs = searchInLogs;
+exports.shouldUseAIFormat = shouldUseAIFormat;
+//# sourceMappingURL=debug.cjs.map
+//# sourceMappingURL=debug.cjs.map