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

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

@@ -0,0 +1,862 @@
+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 };