@ai-setting/roy-agent-core 1.5.14-test → 1.5.15-test

package/dist/shared/@ai-setting/roy-agent-core-g99pxzn5.js

@@ -1,862 +0,0 @@
-import {
-  TraceFormatter,
-  TreeFormatter
-} from "./roy-agent-core-rvv6ydff.js";
-import {
-  BaseComponent
-} from "./roy-agent-core-kkbwepqb.js";
-import {
-  __require
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// src/env/debug/reader/log-reader.ts
-import * as fs from "fs";
-import * as readline from "readline";
-import * as path from "path";
-import { glob } from "glob";
-function getXDGDataHome() {
-  return process.env.XDG_DATA_HOME || path.join(process.env.HOME || "/home/" + (process.env.USER || "user"), ".local", "share");
-}
-
-class LogReader {
-  logDir;
-  constructor(options) {
-    this.logDir = options?.logDir || path.join(getXDGDataHome(), "roy-agent", "logs");
-  }
-  getLogPath(filename) {
-    if (!filename) {
-      return path.join(this.logDir, "app.log");
-    }
-    if (path.isAbsolute(filename)) {
-      return filename;
-    }
-    return path.join(this.logDir, filename);
-  }
-  async findLogFiles(pattern = "*.log") {
-    try {
-      const normalizedDir = this.logDir.replace(/\\/g, "/");
-      const fullPattern = `${normalizedDir}/${pattern}`;
-      const files = await glob(fullPattern);
-      return files.sort();
-    } catch {
-      return [];
-    }
-  }
-  getDefaultLogDir() {
-    return this.logDir;
-  }
-  async* readLines(filepath, options) {
-    const sinceTime = options?.since ? this.parseTime(options.since) : null;
-    const untilTime = options?.until ? this.parseTime(options.until) : null;
-    if (!fs.existsSync(filepath)) {
-      return;
-    }
-    const fileStream = fs.createReadStream(filepath, { encoding: "utf-8" });
-    const rl = readline.createInterface({
-      input: fileStream,
-      crlfDelay: Infinity
-    });
-    try {
-      for await (const line of rl) {
-        if (!line.trim())
-          continue;
-        if (sinceTime || untilTime) {
-          const lineTime = this.extractTimestamp(line);
-          if (lineTime) {
-            if (sinceTime && lineTime < sinceTime)
-              continue;
-            if (untilTime && lineTime > untilTime)
-              continue;
-          }
-        }
-        yield line;
-      }
-    } finally {
-      rl.close();
-      fileStream.destroy();
-    }
-  }
-  extractTimestamp(line) {
-    const match = line.match(/^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}:\d{2})/);
-    if (!match)
-      return null;
-    const datePart = match[1];
-    const timePart = match[2];
-    const isoString = `${datePart}T${timePart}`;
-    const timestamp = new Date(isoString).getTime();
-    return isNaN(timestamp) ? null : timestamp;
-  }
-  parseTime(timeStr) {
-    const now = Date.now();
-    const normalizedStr = timeStr.replace("T", " ");
-    const absoluteTime = new Date(normalizedStr).getTime();
-    if (!isNaN(absoluteTime) && absoluteTime > 0) {
-      return absoluteTime;
-    }
-    const originalTime = new Date(timeStr).getTime();
-    if (!isNaN(originalTime) && originalTime > 0) {
-      return originalTime;
-    }
-    const relativeMatch = timeStr.match(/^(\d+)([hms])$/);
-    if (relativeMatch) {
-      const value = parseInt(relativeMatch[1], 10);
-      const unit = relativeMatch[2];
-      switch (unit) {
-        case "h":
-          return now - value * 60 * 60 * 1000;
-        case "m":
-          return now - value * 60 * 1000;
-        case "s":
-          return now - value * 1000;
-      }
-    }
-    return now;
-  }
-  async readFile(filepath) {
-    return fs.promises.readFile(filepath, "utf-8");
-  }
-  exists(filepath) {
-    return fs.existsSync(filepath);
-  }
-}
-
-// src/env/debug/reader/span-db-reader.ts
-class SpanDbReader {
-  storage = null;
-  dbPath = null;
-  sqliteDb = null;
-  constructor(options) {
-    if (options?.storage) {
-      this.storage = options.storage;
-    } else if (options?.dbPath) {
-      this.dbPath = options.dbPath;
-    }
-  }
-  async initialize() {
-    if (this.storage) {
-      await this.storage.initialize();
-    } else if (this.dbPath) {
-      await this.initSqliteStorage();
-    }
-  }
-  async initSqliteStorage() {
-    try {
-      const { SQLiteSpanStorage } = await import("./roy-agent-core-r9ezzemr.js");
-      this.storage = new SQLiteSpanStorage(this.dbPath);
-      await this.storage.initialize();
-    } catch (error) {
-      throw new Error(`Failed to initialize SQLite storage: ${error}`);
-    }
-  }
-  async getTraceEntries(traceId) {
-    if (!this.storage) {
-      throw new Error("Storage not initialized. Call initialize() first.");
-    }
-    const spans = this.storage.findByTraceId(traceId);
-    if (spans.length === 0) {
-      return [];
-    }
-    return this.spansToEntries(spans);
-  }
-  async listTraceIds(limit = 20) {
-    if (!this.storage) {
-      throw new Error("Storage not initialized. Call initialize() first.");
-    }
-    const traceInfos = this.storage.listTraces(limit);
-    const traceIds = traceInfos.map((info) => ({
-      traceId: info.traceId,
-      firstTime: new Date(info.startTime).toISOString(),
-      lastTime: info.endTime ? new Date(info.endTime).toISOString() : undefined,
-      count: info.spanCount
-    }));
-    return {
-      traceIds,
-      count: traceInfos.length
-    };
-  }
-  spansToEntries(spans) {
-    const entries = [];
-    for (const span of spans) {
-      entries.push({
-        traceId: span.traceId,
-        timestamp: new Date(span.startTime).toISOString(),
-        function: span.name,
-        action: "enter",
-        params: this.attributesToParams(span.attributes),
-        spanId: span.spanId,
-        parentSpanId: span.parentSpanId
-      });
-      if (span.endTime) {
-        entries.push({
-          traceId: span.traceId,
-          timestamp: new Date(span.endTime).toISOString(),
-          function: span.name,
-          action: "quit",
-          result: span.result,
-          error: span.error,
-          durationMs: span.endTime - span.startTime,
-          spanId: span.spanId,
-          parentSpanId: span.parentSpanId
-        });
-      }
-    }
-    entries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-    return entries;
-  }
-  attributesToParams(attributes) {
-    if (!attributes)
-      return [];
-    return Object.entries(attributes).map(([key, value]) => ({
-      key,
-      value
-    }));
-  }
-  getStorage() {
-    return this.storage;
-  }
-  close() {
-    if (this.storage) {
-      this.storage.close();
-      this.storage = null;
-    }
-    if (this.sqliteDb) {
-      this.sqliteDb.close();
-      this.sqliteDb = null;
-    }
-  }
-}
-
-// src/env/debug/parser/regex-parser.ts
-var TRACE_LINE_REGEX = /^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\.\d{3})\s+\[(\w+)\]\s+\[([^\]]*)\]\[([^\]]*)\]\s+\[TRACE\]\s+(>>>|<<<|!!!)\s+(.+?)(?:\s+\[requestId=([^\]]+)\])?\s+(enter|quit|error):\s+(.*)$/;
-var REQUEST_ID_IN_CATEGORY_REGEX = /\[requestId=([^\]]+)\]/;
-
-class RegexParser {
-  parseLogLine(line) {
-    const trimmedLine = line.trim();
-    if (!trimmedLine) {
-      return null;
-    }
-    const match = trimmedLine.match(TRACE_LINE_REGEX);
-    if (!match) {
-      return null;
-    }
-    const [, timestamp, level, source, category, action, method, requestId, actionType, rawArgs] = match;
-    return {
-      raw: trimmedLine,
-      timestamp: timestamp.replace(" ", "T"),
-      level,
-      source,
-      category,
-      action,
-      method,
-      actionType,
-      rawArgs,
-      requestId: requestId || null
-    };
-  }
-  parseArgs(raw) {
-    if (!raw || !raw.trim()) {
-      return null;
-    }
-    const trimmed = raw.trim();
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (Array.isArray(parsed)) {
-        return parsed;
-      }
-      return parsed;
-    } catch {
-      return trimmed;
-    }
-  }
-  isTraceLine(line) {
-    return line.includes("[TRACE]") && (line.includes(">>>") || line.includes("<<<") || line.includes("!!!"));
-  }
-  filterByLevel(lines, level) {
-    if (!level) {
-      return lines;
-    }
-    const levelPattern = `[${level.toUpperCase()}]`;
-    return lines.filter((line) => {
-      if (!this.isTraceLine(line)) {
-        return false;
-      }
-      return line.includes(levelPattern);
-    });
-  }
-  filterByFunction(lines, functionName) {
-    if (!functionName) {
-      return lines;
-    }
-    return lines.filter((line) => {
-      return line.includes(functionName);
-    });
-  }
-  extractTraceId(line) {
-    const categoryMatch = line.match(REQUEST_ID_IN_CATEGORY_REGEX);
-    if (categoryMatch) {
-      return categoryMatch[1];
-    }
-    const match = line.match(TRACE_LINE_REGEX);
-    if (match && match[7]) {
-      return match[7];
-    }
-    return null;
-  }
-  extractTraceIds(lines) {
-    const traceIdMap = new Map;
-    for (const line of lines) {
-      if (!this.isTraceLine(line))
-        continue;
-      const traceId = this.extractTraceId(line);
-      const parsed = this.parseLogLine(line);
-      if (traceId && parsed) {
-        const existing = traceIdMap.get(traceId) || [];
-        existing.push(line);
-        traceIdMap.set(traceId, existing);
-      }
-    }
-    return traceIdMap;
-  }
-  parseLines(lines) {
-    const results = [];
-    for (const line of lines) {
-      const parsed = this.parseLogLine(line);
-      if (parsed) {
-        results.push(parsed);
-      }
-    }
-    return results;
-  }
-}
-
-// src/env/debug/parser/span-builder.ts
-class SpanBuilder {
-  parser;
-  constructor() {
-    this.parser = new RegexParser;
-  }
-  buildTraceEntries(lines) {
-    const entries = [];
-    for (const line of lines) {
-      const entry = this.buildTraceEntry(line);
-      if (entry) {
-        entries.push(entry);
-      }
-    }
-    entries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-    return entries;
-  }
-  buildTraceEntry(line) {
-    const traceId = line.requestId || this.extractTraceId(line.raw);
-    const entry = {
-      traceId: traceId || this.generateVirtualTraceId(line.method, line.timestamp),
-      timestamp: line.timestamp,
-      function: line.method,
-      action: line.actionType
-    };
-    switch (line.actionType) {
-      case "enter":
-        entry.params = this.parser.parseArgs(line.rawArgs);
-        break;
-      case "quit":
-        entry.result = this.parser.parseArgs(line.rawArgs);
-        break;
-      case "error":
-        entry.error = line.rawArgs;
-        break;
-    }
-    return entry;
-  }
-  generateVirtualTraceId(functionName, timestamp) {
-    const base = `${functionName}:${timestamp}`;
-    let hash = 0;
-    for (let i = 0;i < base.length; i++) {
-      const char = base.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
-    }
-    return `vtrace_${Math.abs(hash).toString(36)}`;
-  }
-  extractTraceId(line) {
-    return this.parser.extractTraceId(line);
-  }
-  calculateDuration(enter, quit) {
-    try {
-      const enterTime = new Date(enter.timestamp).getTime();
-      const quitTime = new Date(quit.timestamp).getTime();
-      if (isNaN(enterTime) || isNaN(quitTime)) {
-        return 0;
-      }
-      return quitTime - enterTime;
-    } catch {
-      return 0;
-    }
-  }
-  pairEnterQuit(entries) {
-    const paired = [];
-    const enterStack = [];
-    for (const entry of entries) {
-      if (entry.action === "enter") {
-        enterStack.push(entry);
-      } else if (entry.action === "quit" && enterStack.length > 0) {
-        const enter = enterStack.pop();
-        const duration = this.calculateDuration(enter, entry);
-        paired.push({
-          enter,
-          quit: entry,
-          durationMs: duration
-        });
-      }
-    }
-    return paired;
-  }
-  buildCallTree(entries) {
-    if (entries.length === 0) {
-      return null;
-    }
-    const hasSpanHierarchy = entries.some((e) => e.spanId !== undefined || e.parentSpanId !== undefined);
-    if (hasSpanHierarchy) {
-      return this.buildCallTreeFromHierarchy(entries);
-    }
-    return this.buildCallTreeFromPairs(entries);
-  }
-  buildCallTreeFromHierarchy(entries) {
-    const nodeMap = new Map;
-    const rootNodes = [];
-    const addedToRoots = new Set;
-    const enterEntries = entries.filter((e) => e.action === "enter");
-    for (const entry of enterEntries) {
-      const spanId = entry.spanId;
-      const parentSpanId = entry.parentSpanId;
-      if (spanId && nodeMap.has(spanId)) {
-        continue;
-      }
-      const node = {
-        traceId: entry.traceId,
-        function: entry.function,
-        startTime: entry.timestamp,
-        endTime: undefined,
-        durationMs: entry.durationMs,
-        children: [],
-        entry,
-        spanId,
-        parentSpanId
-      };
-      if (spanId) {
-        nodeMap.set(spanId, node);
-      }
-      if (!parentSpanId || !nodeMap.has(parentSpanId)) {
-        rootNodes.push(node);
-        if (spanId)
-          addedToRoots.add(spanId);
-      }
-    }
-    const quitEntries = entries.filter((e) => e.action === "quit");
-    for (const quit of quitEntries) {
-      if (quit.spanId) {
-        const node = nodeMap.get(quit.spanId);
-        if (node) {
-          node.endTime = quit.timestamp;
-          node.durationMs = quit.durationMs || (node.endTime && node.startTime ? new Date(node.endTime).getTime() - new Date(node.startTime).getTime() : undefined);
-        }
-      }
-    }
-    for (const node of nodeMap.values()) {
-      if (node.parentSpanId && nodeMap.has(node.parentSpanId)) {
-        const parent = nodeMap.get(node.parentSpanId);
-        if (parent.traceId === node.traceId) {
-          parent.children.push(node);
-          rootNodes.splice(rootNodes.indexOf(node), 1);
-        }
-      }
-    }
-    if (rootNodes.length === 0) {
-      for (const entry of enterEntries) {
-        if (!entry.parentSpanId) {
-          const spanId = entry.spanId;
-          if (spanId && nodeMap.has(spanId) && !addedToRoots.has(spanId)) {
-            rootNodes.push(nodeMap.get(spanId));
-          }
-        }
-      }
-    }
-    rootNodes.sort((a, b) => a.startTime.localeCompare(b.startTime));
-    if (rootNodes.length === 0) {
-      return null;
-    }
-    if (rootNodes.length === 1) {
-      return rootNodes[0];
-    }
-    const allStartTimes = rootNodes.map((n) => new Date(n.startTime).getTime());
-    const allEndTimes = rootNodes.map((n) => n.endTime ? new Date(n.endTime).getTime() : 0).filter((t) => t > 0);
-    return {
-      traceId: entries[0]?.traceId || "merged",
-      function: "(root)",
-      children: rootNodes,
-      startTime: new Date(Math.min(...allStartTimes)).toISOString(),
-      endTime: allEndTimes.length > 0 ? new Date(Math.max(...allEndTimes)).toISOString() : undefined,
-      durationMs: allEndTimes.length > 0 && allStartTimes.length > 0 ? Math.max(...allEndTimes) - Math.min(...allStartTimes) : undefined
-    };
-  }
-  buildCallTreeFromPairs(entries) {
-    const sortedEntries = [...entries].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-    const paired = this.pairEnterQuit(sortedEntries);
-    if (paired.length === 0) {
-      return null;
-    }
-    const stack = [];
-    let root = null;
-    for (const entry of sortedEntries) {
-      if (entry.action === "enter") {
-        const span = paired.find((p) => p.enter === entry);
-        if (!span)
-          continue;
-        const node = this.buildNodeFromPaired(span);
-        if (stack.length === 0) {
-          root = node;
-        } else {
-          stack[stack.length - 1].node.children.push(node);
-        }
-        stack.push({ node, paired: span });
-      } else if (entry.action === "quit" && stack.length > 0) {
-        stack.pop();
-      }
-    }
-    return root;
-  }
-  buildNodeFromPaired(span) {
-    return {
-      traceId: span.enter.traceId,
-      function: span.enter.function,
-      startTime: span.enter.timestamp,
-      endTime: span.quit.timestamp,
-      durationMs: span.durationMs,
-      children: [],
-      entry: span.enter
-    };
-  }
-  buildMergedTree(entriesByFunction) {
-    const allEntries = [];
-    for (const entries of entriesByFunction.values()) {
-      allEntries.push(...entries);
-    }
-    allEntries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-    return this.buildCallTree(allEntries);
-  }
-  getDurationSummary(entries) {
-    const summary = new Map;
-    const paired = this.pairEnterQuit(entries);
-    for (const span of paired) {
-      const func = span.enter.function;
-      const existing = summary.get(func) || { count: 0, totalMs: 0, avgMs: 0 };
-      existing.count++;
-      existing.totalMs += span.durationMs;
-      existing.avgMs = Math.round(existing.totalMs / existing.count);
-      summary.set(func, existing);
-    }
-    return summary;
-  }
-}
-
-// src/env/debug/debug-component.ts
-class DebugComponent extends BaseComponent {
-  name = "debug";
-  version = "1.0.0";
-  reader;
-  spanDbReader = null;
-  parser;
-  spanBuilder;
-  traceFormatter;
-  treeFormatter;
-  options;
-  constructor(options) {
-    super();
-    this.options = options || {};
-    this.reader = new LogReader({ logDir: this.options.logDir });
-    this.parser = new RegexParser;
-    this.spanBuilder = new SpanBuilder;
-    this.traceFormatter = new TraceFormatter;
-    this.treeFormatter = new TreeFormatter;
-  }
-  async initSpanDbReader(dbPath) {
-    if (!this.spanDbReader) {
-      this.spanDbReader = new SpanDbReader({ dbPath });
-      await this.spanDbReader.initialize();
-    }
-  }
-  getSpanDbReader() {
-    return this.spanDbReader;
-  }
-  async getLiveTrace(traceId) {
-    try {
-      const { getTracerProvider } = await import("./roy-agent-core-sx7wsvnn.js");
-      const provider = getTracerProvider();
-      if (!provider.isInitialized()) {
-        await provider.initialize();
-      }
-      const storage = provider.getStorage();
-      const spans = storage.findByTraceId(traceId);
-      if (spans.length === 0) {
-        return null;
-      }
-      const flattenSpans = (spanList) => {
-        const result = [];
-        for (const span of spanList) {
-          result.push({
-            traceId: span.traceId,
-            spanId: span.spanId,
-            parentSpanId: span.parentSpanId,
-            function: span.name,
-            action: "enter",
-            timestamp: new Date(span.startTime).toISOString(),
-            params: Object.entries(span.attributes || {}).map(([k, v]) => ({ key: k, value: v }))
-          });
-          if (span.children && span.children.length > 0) {
-            result.push(...flattenSpans(span.children));
-          }
-        }
-        return result;
-      };
-      const flatSpans = flattenSpans(spans);
-      const tree = this.spanBuilder.buildCallTree(flatSpans);
-      const rootSpans = spans.filter((s) => !s.parentSpanId);
-      return {
-        traceId,
-        spans,
-        callTree: tree,
-        spanCount: flatSpans.length,
-        rootSpans
-      };
-    } catch (error) {
-      console.error("Failed to get trace from live storage:", error);
-      return null;
-    }
-  }
-  async listLiveTraces(limit = 20) {
-    try {
-      const { getTracerProvider } = await import("./roy-agent-core-sx7wsvnn.js");
-      const provider = getTracerProvider();
-      if (!provider.isInitialized()) {
-        await provider.initialize();
-      }
-      const storage = provider.getStorage();
-      const traces = storage.listTraces(limit);
-      return {
-        traces,
-        count: traces.length
-      };
-    } catch (error) {
-      console.error("Failed to list live traces:", error);
-      return { traces: [], count: 0 };
-    }
-  }
-  async formatLiveTrace(traceId) {
-    try {
-      const { getTracerProvider } = await import("./roy-agent-core-sx7wsvnn.js");
-      const provider = getTracerProvider();
-      if (!provider.isInitialized()) {
-        await provider.initialize();
-      }
-      const storage = provider.getStorage();
-      const spans = storage.findByTraceId(traceId);
-      if (spans.length === 0) {
-        return `No trace found for traceId: ${traceId}`;
-      }
-      const flattenSpans = (spanList) => {
-        const result = [];
-        for (const span of spanList) {
-          result.push({
-            traceId: span.traceId,
-            spanId: span.spanId,
-            parentSpanId: span.parentSpanId,
-            function: span.name,
-            action: "enter",
-            timestamp: new Date(span.startTime).toISOString(),
-            params: Object.entries(span.attributes || {}).map(([k, v]) => ({ key: k, value: v }))
-          });
-          if (span.children && span.children.length > 0) {
-            result.push(...flattenSpans(span.children));
-          }
-        }
-        return result;
-      };
-      const flatSpans = flattenSpans(spans);
-      const tree = this.spanBuilder.buildCallTree(flatSpans);
-      if (!tree) {
-        return "No trace structure found";
-      }
-      return this.treeFormatter.formatTree(tree);
-    } catch (error) {
-      return `Failed to format trace: ${error}`;
-    }
-  }
-  async init(config) {
-    await super.init(config);
-    this.setStatus("running");
-  }
-  async stop() {
-    this.setStatus("stopping");
-    this.setStatus("stopped");
-  }
-  async getTraces(options) {
-    if (options?.source === "sqlite") {
-      return this.getTracesFromSqlite(options);
-    }
-    const logFile = options?.logFile || this.reader.getLogPath();
-    const lines = [];
-    for await (const line of this.reader.readLines(logFile, options)) {
-      if (options?.function && !line.includes(options.function)) {
-        continue;
-      }
-      if (options?.traceId && !line.includes(`requestId=${options.traceId}`)) {
-        continue;
-      }
-      if (this.parser.isTraceLine(line)) {
-        lines.push(line);
-      }
-    }
-    const parsedLines = this.parser.parseLines(lines);
-    const entries = this.spanBuilder.buildTraceEntries(parsedLines);
-    let filteredEntries = entries;
-    if (options?.function) {
-      filteredEntries = entries.filter((e) => e.function.includes(options.function));
-    }
-    const paired = this.spanBuilder.pairEnterQuit(filteredEntries);
-    const result = [];
-    for (const span of paired) {
-      result.push({
-        ...span.enter,
-        durationMs: span.durationMs
-      });
-      if (span.quit) {
-        result.push({
-          ...span.quit,
-          durationMs: span.durationMs
-        });
-      }
-    }
-    return result;
-  }
-  async getTracesFromSqlite(options) {
-    if (!options?.traceId) {
-      return [];
-    }
-    await this.initSpanDbReader(options.dbPath);
-    const reader = this.getSpanDbReader();
-    if (!reader) {
-      throw new Error("Failed to initialize span database reader");
-    }
-    const entries = await reader.getTraceEntries(options.traceId);
-    if (options?.function) {
-      return entries.filter((e) => e.function.includes(options.function));
-    }
-    return entries;
-  }
-  async listTraceIds(options) {
-    if (options?.source === "sqlite") {
-      return this.listTraceIdsFromSqlite(options);
-    }
-    const logFile = options?.logFile || this.reader.getLogPath();
-    const limit = options?.limit || 20;
-    const traceMap = new Map;
-    for await (const line of this.reader.readLines(logFile, options)) {
-      if (!this.parser.isTraceLine(line))
-        continue;
-      const parsed = this.parser.parseLogLine(line);
-      if (!parsed)
-        continue;
-      const traceId = this.parser.extractTraceId(line) || this.spanBuilder.generateVirtualTraceId(parsed.method, parsed.timestamp);
-      const existing = traceMap.get(traceId);
-      if (existing) {
-        existing.lastTime = parsed.timestamp;
-        existing.count++;
-      } else {
-        traceMap.set(traceId, {
-          firstTime: parsed.timestamp,
-          lastTime: parsed.timestamp,
-          count: 1
-        });
-      }
-    }
-    const traceIds = [];
-    for (const [traceId, info] of traceMap.entries()) {
-      traceIds.push({
-        traceId,
-        firstTime: info.firstTime,
-        lastTime: info.lastTime,
-        count: info.count
-      });
-    }
-    traceIds.sort((a, b) => b.firstTime.localeCompare(a.firstTime));
-    return {
-      traceIds: traceIds.slice(0, limit),
-      count: traceIds.length
-    };
-  }
-  async listTraceIdsFromSqlite(options) {
-    const limit = options?.limit || 20;
-    await this.initSpanDbReader(options?.dbPath);
-    const reader = this.getSpanDbReader();
-    if (!reader) {
-      throw new Error("Failed to initialize span database reader");
-    }
-    return reader.listTraceIds(limit);
-  }
-  async getCallTree(options) {
-    if (!options?.traceId) {
-      return null;
-    }
-    const traces = await this.getTraces({
-      ...options,
-      traceId: options.traceId
-    });
-    if (traces.length === 0) {
-      return null;
-    }
-    return this.spanBuilder.buildCallTree(traces);
-  }
-  getReader() {
-    return this.reader;
-  }
-  getParser() {
-    return this.parser;
-  }
-  getSpanBuilder() {
-    return this.spanBuilder;
-  }
-  getTraceFormatter() {
-    return this.traceFormatter;
-  }
-  getTreeFormatter() {
-    return this.treeFormatter;
-  }
-  formatTraces(entries, options) {
-    return this.traceFormatter.formatEntries(entries, options);
-  }
-  formatTraceEntry(entry, options) {
-    return this.traceFormatter.formatEntry(entry, options);
-  }
-  tracesToJSON(entries) {
-    return this.traceFormatter.toJSON(entries);
-  }
-  tracesToSummary(entries) {
-    return this.traceFormatter.toSummary(entries);
-  }
-  formatTree(node) {
-    return this.treeFormatter.formatTree(node);
-  }
-  formatTrees(trees) {
-    return this.treeFormatter.formatTrees(trees);
-  }
-  treesToJSON(trees) {
-    return this.treeFormatter.toJSON(trees);
-  }
-  formatTreeSummary(node) {
-    return this.treeFormatter.formatSummary(node);
-  }
-  formatTreeTimeline(node) {
-    return this.treeFormatter.formatTimeline(node);
-  }
-}
-export { LogReader, SpanDbReader, RegexParser, SpanBuilder, DebugComponent };