@ai-setting/roy-agent-core 1.4.11 → 1.4.12

package/dist/env/debug/index.js

@@ -0,0 +1,2300 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// packages/core/src/env/log-trace/span-storage.ts
+var exports_span_storage = {};
+__export(exports_span_storage, {
+  SQLiteSpanStorage: () => SQLiteSpanStorage
+});
+
+class SQLiteSpanStorage {
+  db = null;
+  dbPath;
+  initialized = false;
+  constructor(dbPath) {
+    if (!dbPath) {
+      throw new Error("SQLiteSpanStorage requires a valid dbPath parameter");
+    }
+    if (dbPath === ":memory:") {
+      throw new Error("SQLiteSpanStorage does not support :memory: mode. Use a file path instead.");
+    }
+    this.dbPath = dbPath;
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    const { Database } = __require("bun:sqlite");
+    const fs2 = __require("fs");
+    const path2 = __require("path");
+    const dir = path2.dirname(this.dbPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(this.dbPath);
+    this.db.run("PRAGMA journal_mode=WAL");
+    this.db.run("PRAGMA busy_timeout=5000");
+    this.db.run("PRAGMA synchronous=NORMAL");
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS span (
+        span_id TEXT PRIMARY KEY,
+        trace_id TEXT NOT NULL,
+        parent_span_id TEXT,
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        status TEXT NOT NULL,
+        start_time INTEGER NOT NULL,
+        end_time INTEGER,
+        attributes TEXT,
+        result TEXT,
+        error TEXT,
+        time_created INTEGER NOT NULL
+      )
+    `);
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_trace ON span(trace_id)");
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_parent ON span(parent_span_id)");
+    this.initialized = true;
+  }
+  save(span) {
+    if (!this.db)
+      return;
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO span 
+      (span_id, trace_id, parent_span_id, name, kind, status, start_time, end_time, attributes, result, error, time_created)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const resultValue = span.result !== undefined && span.result !== null ? typeof span.result === "string" ? span.result : JSON.stringify(span.result) : null;
+    stmt.run(span.spanId, span.traceId, span.parentSpanId || null, span.name, span.kind, span.status, span.startTime, span.endTime || null, JSON.stringify(span.attributes), resultValue, span.error || null, Date.now());
+  }
+  saveBatch(spans) {
+    for (const span of spans) {
+      this.save(span);
+    }
+  }
+  findByTraceId(traceId) {
+    if (!this.db)
+      return [];
+    const rows = this.db.prepare("SELECT * FROM span WHERE trace_id = ?").all(traceId);
+    return this.buildTree(rows.map(this.rowToSpan));
+  }
+  findBySpanId(spanId) {
+    if (!this.db)
+      return;
+    const row = this.db.prepare("SELECT * FROM span WHERE span_id = ?").get(spanId);
+    return row ? this.rowToSpan(row) : undefined;
+  }
+  listTraces(limit = 10) {
+    if (!this.db)
+      return [];
+    const rows = this.db.prepare(`
+      SELECT trace_id, 
+             MIN(start_time) as start_time,
+             MAX(end_time) as end_time,
+             COUNT(*) as span_count
+      FROM span 
+      GROUP BY trace_id 
+      ORDER BY start_time DESC 
+      LIMIT ?
+    `).all(limit);
+    return rows.map((row) => ({
+      traceId: row.trace_id,
+      rootSpanName: "unknown",
+      startTime: row.start_time,
+      endTime: row.end_time,
+      duration: row.end_time - row.start_time,
+      spanCount: row.span_count,
+      status: "ok"
+    }));
+  }
+  deleteByTraceId(traceId) {
+    if (this.db) {
+      this.db.prepare("DELETE FROM span WHERE trace_id = ?").run(traceId);
+    }
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  rowToSpan(row) {
+    return {
+      traceId: row.trace_id,
+      spanId: row.span_id,
+      parentSpanId: row.parent_span_id,
+      name: row.name,
+      kind: row.kind,
+      status: row.status,
+      startTime: row.start_time,
+      endTime: row.end_time,
+      attributes: row.attributes ? JSON.parse(row.attributes) : {},
+      result: row.result || undefined,
+      error: row.error || undefined
+    };
+  }
+  buildTree(spans) {
+    const spanMap = new Map;
+    const roots = [];
+    for (const span of spans) {
+      spanMap.set(span.spanId, { ...span, children: [] });
+    }
+    for (const span of spanMap.values()) {
+      if (span.parentSpanId) {
+        const parent = spanMap.get(span.parentSpanId);
+        if (parent) {
+          parent.children.push(span);
+        } else {
+          roots.push(span);
+        }
+      } else {
+        roots.push(span);
+      }
+    }
+    return roots;
+  }
+}
+
+// packages/core/src/env/log-trace/opentelemetry/propagation.ts
+function padLeft(str, length) {
+  return str.padStart(length, "0");
+}
+function isValidHex(str) {
+  return /^[0-9a-f]+$/i.test(str);
+}
+function serialize(context) {
+  const traceId = padLeft(context.traceId.toLowerCase(), TRACE_ID_LENGTH);
+  const spanId = padLeft(context.spanId.toLowerCase(), PARENT_SPAN_ID_LENGTH);
+  const parts = [
+    TRACE_CONTEXT_VERSION,
+    traceId,
+    spanId,
+    TRACE_FLAGS_SAMPLED
+  ];
+  return parts.join("-");
+}
+function parse(traceparent) {
+  if (!traceparent || typeof traceparent !== "string") {
+    return;
+  }
+  const trimmed = traceparent.trim();
+  const parts = trimmed.split("-");
+  if (parts.length !== 4) {
+    return;
+  }
+  const [version, traceId, senderSpanId, flags] = parts;
+  if (version !== TRACE_CONTEXT_VERSION) {
+    if (version > TRACE_CONTEXT_VERSION) {
+      return;
+    }
+  }
+  if (traceId.length !== TRACE_ID_LENGTH || !isValidHex(traceId)) {
+    return;
+  }
+  if (senderSpanId.length !== PARENT_SPAN_ID_LENGTH || !isValidHex(senderSpanId)) {
+    return;
+  }
+  if (flags.length !== FLAGS_LENGTH || !isValidHex(flags)) {
+    return;
+  }
+  return {
+    traceId: traceId.toLowerCase(),
+    spanId: senderSpanId.toLowerCase()
+  };
+}
+var TRACE_CONTEXT_VERSION = "00", TRACE_FLAGS_SAMPLED = "01", TRACEPARENT_HEADER = "TRACEPARENT", TRACE_ID_LENGTH = 32, PARENT_SPAN_ID_LENGTH = 16, FLAGS_LENGTH = 2, propagation;
+var init_propagation = __esm(() => {
+  propagation = {
+    inject(carrier, context) {
+      carrier[TRACEPARENT_HEADER] = serialize(context);
+    },
+    extract(carrier) {
+      const traceparent = carrier[TRACEPARENT_HEADER];
+      if (!traceparent) {
+        return;
+      }
+      return parse(traceparent);
+    },
+    getTraceparentHeader() {
+      return TRACEPARENT_HEADER;
+    }
+  };
+});
+
+// packages/core/src/env/log-trace/types.ts
+var SpanKind, SpanStatus;
+var init_types = __esm(() => {
+  ((SpanKind2) => {
+    SpanKind2["CLIENT"] = "client";
+    SpanKind2["SERVER"] = "server";
+    SpanKind2["INTERNAL"] = "internal";
+  })(SpanKind ||= {});
+  ((SpanStatus2) => {
+    SpanStatus2["OK"] = "ok";
+    SpanStatus2["ERROR"] = "error";
+  })(SpanStatus ||= {});
+});
+
+// packages/core/src/env/log-trace/opentelemetry/tracer-provider.ts
+var exports_tracer_provider = {};
+__export(exports_tracer_provider, {
+  resetTracerProvider: () => resetTracerProvider,
+  getTracerProvider: () => getTracerProvider,
+  OTelTracerProvider: () => OTelTracerProvider
+});
+
+class OTelSpanImpl {
+  name;
+  kind;
+  spanContext;
+  attributes = {};
+  startTime;
+  endTime;
+  error;
+  storage;
+  parentSpanContext;
+  onEnd;
+  constructor(name, spanContext, storage, parentSpanContext, onEnd) {
+    this.name = name;
+    this.kind = "internal";
+    this.spanContext = spanContext;
+    this.parentSpanContext = parentSpanContext;
+    this.startTime = Date.now();
+    this.storage = storage;
+    this.onEnd = onEnd;
+  }
+  setAttribute(key, value) {
+    this.attributes[key] = value;
+  }
+  addEvent(name, attributes) {
+    const events = this.attributes._events || [];
+    events.push({ name, attributes });
+    this.attributes._events = events;
+  }
+  end(result, error) {
+    this.endTime = Date.now();
+    if (error) {
+      this.error = error.message;
+    }
+    this.storage.save({
+      traceId: this.spanContext.traceId,
+      spanId: this.spanContext.spanId,
+      parentSpanId: this.spanContext.parentSpanId,
+      name: this.name,
+      kind: this.kind,
+      status: error ? "error" /* ERROR */ : "ok" /* OK */,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      attributes: this.attributes,
+      result,
+      error: this.error
+    });
+    this.onEnd?.();
+  }
+}
+
+class OTelTracerImpl {
+  name;
+  version;
+  storage;
+  currentContext;
+  activeSpans = new Map;
+  onSpanEndCallback;
+  provider;
+  constructor(name, version, storage, provider) {
+    this.name = name;
+    this.version = version;
+    this.storage = storage;
+    this.provider = provider;
+  }
+  setOnSpanEndCallback(callback) {
+    this.onSpanEndCallback = callback;
+  }
+  getActiveSpanCount() {
+    return this.activeSpans.size;
+  }
+  startSpan(name, options) {
+    const parentFromOptions = options?.parent;
+    const hasExplicitParent = options && "parent" in options;
+    const globalContext = this.provider.getGlobalContext();
+    let effectiveParentContext;
+    if (hasExplicitParent) {
+      effectiveParentContext = parentFromOptions;
+    } else if (this.currentContext) {
+      effectiveParentContext = this.currentContext;
+    } else if (globalContext) {
+      effectiveParentContext = globalContext;
+    }
+    const traceId = effectiveParentContext?.traceId || this.generateTraceId();
+    const spanId = this.generateSpanId();
+    let parentSpanId;
+    if (hasExplicitParent && parentFromOptions) {
+      parentSpanId = parentFromOptions.parentSpanId || parentFromOptions.spanId;
+    } else if (this.currentContext) {
+      parentSpanId = this.currentContext.spanId;
+    } else if (globalContext) {
+      parentSpanId = globalContext.spanId;
+    }
+    const spanContext = {
+      traceId,
+      spanId,
+      parentSpanId
+    };
+    this.currentContext = {
+      traceId,
+      spanId,
+      parentSpanId
+    };
+    const span = new OTelSpanImpl(name, spanContext, this.storage, effectiveParentContext, () => this.handleSpanEnd(spanContext.spanId, effectiveParentContext?.spanId));
+    if (options?.attributes) {
+      for (const [key, value] of Object.entries(options.attributes)) {
+        span.setAttribute(key, value);
+      }
+    }
+    this.activeSpans.set(spanId, span);
+    return span;
+  }
+  injectToEnv(env) {
+    if (this.currentContext) {
+      propagation.inject(env, this.currentContext);
+    }
+  }
+  getCurrentContext() {
+    return this.currentContext;
+  }
+  setCurrentContext(context) {
+    this.currentContext = context;
+  }
+  endSpan(span) {
+    const spanContext = span.spanContext;
+    this.activeSpans.delete(spanContext.spanId);
+    const currentTraceId = this.currentContext?.traceId;
+    if (spanContext.parentSpanId) {
+      const parentSpan = this.activeSpans.get(spanContext.parentSpanId);
+      if (parentSpan) {
+        const parentContext = {
+          traceId: spanContext.traceId,
+          spanId: parentSpan.spanContext.spanId,
+          parentSpanId: parentSpan.spanContext.parentSpanId
+        };
+        this.currentContext = parentContext;
+        return parentContext;
+      }
+      if (currentTraceId) {
+        const parentContext = {
+          traceId: currentTraceId,
+          spanId: spanContext.parentSpanId,
+          parentSpanId: undefined
+        };
+        this.currentContext = parentContext;
+        return parentContext;
+      }
+    }
+    this.currentContext = undefined;
+    return;
+  }
+  generateTraceId() {
+    const timestamp = Date.now().toString(16).padStart(12, "0");
+    const random = Array.from({ length: 5 }, () => Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0")).join("");
+    return (timestamp + random).slice(0, 32).padStart(32, "0");
+  }
+  generateSpanId() {
+    return Math.floor(Math.random() * 18446744073709552000).toString(16).padStart(16, "0");
+  }
+  handleSpanEnd(spanId, parentSpanId) {
+    this.activeSpans.delete(spanId);
+    const currentTraceId = this.currentContext?.traceId;
+    if (parentSpanId) {
+      const parentSpan = this.activeSpans.get(parentSpanId);
+      if (parentSpan) {
+        this.currentContext = {
+          traceId: parentSpan.spanContext.traceId,
+          spanId: parentSpan.spanContext.spanId,
+          parentSpanId: parentSpan.spanContext.parentSpanId
+        };
+        return;
+      }
+      if (currentTraceId) {
+        this.currentContext = {
+          traceId: currentTraceId,
+          spanId: parentSpanId,
+          parentSpanId: undefined
+        };
+        return;
+      }
+    }
+    this.currentContext = undefined;
+  }
+}
+
+class OTelTracerProvider {
+  tracers = new Map;
+  storage;
+  initialized = false;
+  globalContext;
+  constructor(storage, dbPath) {
+    this.storage = storage || new SQLiteSpanStorage(dbPath || getDefaultDbPath());
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    await this.storage.initialize();
+    this.initialized = true;
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  getGlobalContext() {
+    return this.globalContext;
+  }
+  setGlobalContext(context) {
+    this.globalContext = context;
+  }
+  getTracer(name, version) {
+    const key = `${name}@${version || "0.0.0"}`;
+    let tracer = this.tracers.get(key);
+    if (!tracer) {
+      tracer = new OTelTracerImpl(name, version, this.storage, this);
+      this.tracers.set(key, tracer);
+      if (this.initialized) {
+        this.restoreFromEnv(tracer);
+      }
+    }
+    return tracer;
+  }
+  restoreFromEnv(tracer) {
+    const extracted = propagation.extract(process.env);
+    if (extracted) {
+      tracer.setCurrentContext({
+        traceId: extracted.traceId,
+        spanId: extracted.spanId,
+        parentSpanId: undefined
+      });
+    }
+  }
+  shutdown() {
+    for (const tracer of this.tracers.values()) {}
+    this.tracers.clear();
+    this.storage.close();
+    this.initialized = false;
+    this.globalContext = undefined;
+    delete process.env["TRACEPARENT"];
+    delete process.env["TRACE_ID"];
+    delete process.env["LOG_TRACE_REQUEST_ID"];
+  }
+  getStorage() {
+    return this.storage;
+  }
+}
+function getTracerProvider() {
+  if (!providerInstance) {
+    providerInstance = new OTelTracerProvider;
+  }
+  return providerInstance;
+}
+function resetTracerProvider() {
+  if (providerInstance) {
+    providerInstance.shutdown();
+    providerInstance = null;
+  }
+}
+function getDefaultDbPath() {
+  const os = __require("os");
+  const path2 = __require("path");
+  const home = os.homedir();
+  const dataHome = process.env.XDG_DATA_HOME || path2.join(home, ".local", "share");
+  return path2.join(dataHome, "roy-agent", "traces.db");
+}
+var providerInstance = null;
+var init_tracer_provider = __esm(() => {
+  init_propagation();
+  init_types();
+});
+
+// packages/core/src/env/hook/types.ts
+function createHook(meta, fn) {
+  return {
+    ...meta,
+    execute: fn
+  };
+}
+function createPriorityHook(name, fn, priority) {
+  return createHook({ name, priority }, fn);
+}
+// packages/core/src/env/hook/hook-manager.ts
+class HookManager {
+  _hooks = new Map;
+  componentName;
+  componentVersion;
+  defaultPriority;
+  constructor(options = {}) {
+    this.componentName = options.componentName ?? "unknown";
+    this.componentVersion = options.componentVersion ?? "0.0.0";
+    this.defaultPriority = options.defaultPriority ?? 0;
+  }
+  register(hookPoint, hook) {
+    const hooks = this.getOrCreateHooks(hookPoint);
+    hooks.push(hook);
+  }
+  registerMany(hookPoint, hooks) {
+    const hookList = this.getOrCreateHooks(hookPoint);
+    hookList.push(...hooks);
+  }
+  unregister(hookPoint, name) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks)
+      return false;
+    const index = hooks.findIndex((h) => h.name === name);
+    if (index === -1)
+      return false;
+    hooks.splice(index, 1);
+    return true;
+  }
+  unregisterAll(hookPoint) {
+    this._hooks.delete(hookPoint);
+  }
+  async execute(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0)
+      return;
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    for (const hook of sortedHooks) {
+      await this.safeExecute(hook, ctx);
+    }
+  }
+  async executeAndCollect(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0)
+      return [];
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    const results = [];
+    for (const hook of sortedHooks) {
+      const result = await this.safeExecuteAndReturn(hook, ctx);
+      if (result !== undefined) {
+        results.push(result);
+      }
+    }
+    return results;
+  }
+  count(hookPoint) {
+    return this._hooks.get(hookPoint)?.length ?? 0;
+  }
+  clear() {
+    this._hooks.clear();
+  }
+  getHookPoints() {
+    return Array.from(this._hooks.keys());
+  }
+  hasHooks(hookPoint) {
+    return this.count(hookPoint) > 0;
+  }
+  setComponentInfo(name, version) {
+    this.componentName = name;
+    this.componentVersion = version;
+  }
+  get hooks() {
+    return this._hooks;
+  }
+  async executeWithIntervention(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0) {
+      return { stopped: false, results: [] };
+    }
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    const results = [];
+    let stopped = false;
+    let action;
+    for (const hook of sortedHooks) {
+      if (stopped)
+        break;
+      const result = await this.safeExecuteAndReturn(hook, ctx);
+      results.push(result);
+      if (result && typeof result === "object" && "stopped" in result) {
+        const hookResult = result;
+        if (hookResult.stopped) {
+          stopped = true;
+          action = hookResult.action;
+        }
+      }
+    }
+    return { stopped, action, results };
+  }
+  getOrCreateHooks(hookPoint) {
+    let hooks = this._hooks.get(hookPoint);
+    if (!hooks) {
+      hooks = [];
+      this._hooks.set(hookPoint, hooks);
+    }
+    return hooks;
+  }
+  sortHooks(hooks) {
+    return [...hooks].sort((a, b) => {
+      const priorityA = a.priority ?? this.defaultPriority;
+      const priorityB = b.priority ?? this.defaultPriority;
+      return priorityA - priorityB;
+    });
+  }
+  createContext(hookPoint, data, metadata, phase) {
+    return {
+      component: {
+        name: this.componentName,
+        version: this.componentVersion
+      },
+      data,
+      metadata,
+      phase,
+      hookPoint
+    };
+  }
+  async safeExecute(hook, ctx) {
+    try {
+      await hook.execute(ctx);
+    } catch (error) {
+      console.error(`Hook "${hook.name}" failed:`, error);
+    }
+  }
+  async safeExecuteAndReturn(hook, ctx) {
+    try {
+      return await hook.execute(ctx);
+    } catch (error) {
+      console.error(`Hook "${hook.name}" failed:`, error);
+      return;
+    }
+  }
+}
+// packages/core/src/env/hook/global-hook-manager.ts
+var globalHookManager = new HookManager;
+var AgentHookPoints = {
+  BEFORE_START: "agent:before.start",
+  BEFORE_LLM: "agent:before.llm",
+  AFTER_LLM: "agent:after.llm",
+  BEFORE_TOOL: "agent:before.tool",
+  AFTER_TOOL: "agent:after.tool",
+  ON_ITERATION: "agent:on.iteration",
+  ON_THRESHOLD: "agent:on.threshold",
+  AFTER_COMPLETE: "agent:after.complete",
+  ON_ERROR: "agent:on.error"
+};
+var LLMHookPoints = {
+  BEFORE_INVOKE: "llm:before.invoke",
+  AFTER_INVOKE: "llm:after.invoke",
+  ON_STREAM: "llm:on.stream"
+};
+var ToolHookPoints = {
+  BEFORE_EXECUTE: "tool:before.execute",
+  AFTER_EXECUTE: "tool:after.execute",
+  BEFORE_REGISTER: "tool:before.register",
+  AFTER_REGISTER: "tool:after.register",
+  ON_ERROR: "tool:on.error"
+};
+var hookPointAliases = {
+  "before.tool": "tool:before.execute",
+  "after.tool": "tool:after.execute",
+  "llm.before-invoke": "llm:before.invoke",
+  "llm.after-invoke": "llm:after.invoke",
+  "llm.stream": "llm:on.stream"
+};
+function setupAliasHooks() {
+  const originalRegister = globalHookManager.register.bind(globalHookManager);
+  globalHookManager.register = function(hookPoint, hook) {
+    originalRegister(hookPoint, hook);
+    const alias = hookPointAliases[hookPoint];
+    if (alias) {
+      originalRegister(alias, hook);
+    }
+  };
+}
+setupAliasHooks();
+async function executeAgentHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+async function executeAgentHookWithIntervention(hookPoint, data, metadata = {}) {
+  return globalHookManager.executeWithIntervention(hookPoint, data, metadata);
+}
+async function executeLLMHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+async function executeToolHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+// packages/core/src/env/debug/formatters/trace-formatter.ts
+class TraceFormatter {
+  formatEntry(entry, options = {}) {
+    const { pretty = false } = options;
+    const actionSymbol = entry.action === "enter" ? ">>>" : entry.action === "error" ? "!!!" : "<<<";
+    let output = `${actionSymbol} ${entry.function} ${entry.action}`;
+    if (entry.action === "enter" && entry.params) {
+      output += `
+` + this.formatData(entry.params, options);
+    } else if (entry.action === "quit") {
+      if (entry.durationMs !== undefined) {
+        output += ` (${entry.durationMs}ms)`;
+      }
+      if (entry.result) {
+        output += `
+` + this.formatData(entry.result, options);
+      }
+    } else if (entry.action === "error" && entry.error) {
+      output += `: ${entry.error}`;
+    }
+    if (pretty) {
+      output = this.indentMultilineContent(output);
+    }
+    return output;
+  }
+  indentMultilineContent(text, indent = "  ") {
+    const lines = text.split(`
+`);
+    if (lines.length <= 1)
+      return text;
+    return lines.map((line, i) => i === 0 ? line : `${indent}${line}`).join(`
+`);
+  }
+  formatEntries(entries, options = {}) {
+    if (entries.length === 0) {
+      return "No trace entries";
+    }
+    const formatted = entries.map((entry) => this.formatEntry(entry, options));
+    if (options.pretty) {
+      return formatted.join(`
+` + "-".repeat(80) + `
+`);
+    }
+    return formatted.join(`
+`);
+  }
+  formatData(data, options = {}) {
+    const { pretty = false, maxDepth = 10 } = options;
+    if (pretty) {
+      return this.formatPretty(data, 0, maxDepth);
+    }
+    return JSON.stringify(data);
+  }
+  formatPretty(data, indent = 0, maxDepth) {
+    const baseIndent = "  ".repeat(indent);
+    const nextIndent = "  ".repeat(indent + 1);
+    if (data === null || data === undefined) {
+      return String(data);
+    }
+    if (typeof data === "string") {
+      if (data.includes(`
+`)) {
+        return data.split(`
+`).map((line, i) => i === 0 ? line : `${nextIndent}${line}`).join(`
+`);
+      }
+      return data;
+    }
+    if (typeof data === "number" || typeof data === "boolean") {
+      return String(data);
+    }
+    if (Array.isArray(data)) {
+      if (data.length === 0)
+        return "[]";
+      const items = data.map((item) => {
+        const formatted = this.formatPretty(item, indent + 1, maxDepth);
+        return formatted.split(`
+`).map((line) => `  ${line}`).join(`
+`);
+      });
+      return `[
+` + items.join(`,
+`) + `
+` + baseIndent + "]";
+    }
+    if (typeof data === "object") {
+      const obj = data;
+      const keys = Object.keys(obj);
+      if (keys.length === 0)
+        return "{}";
+      if (indent >= maxDepth) {
+        return "{...}";
+      }
+      const entries = keys.map((key) => {
+        const value = obj[key];
+        let formatted;
+        if (typeof value === "object" && value !== null) {
+          formatted = this.formatPretty(value, indent + 1, maxDepth);
+        } else if (typeof value === "string" && value.includes(`
+`)) {
+          formatted = value.split(`
+`).map((line, i) => i === 0 ? line : `${nextIndent}${line}`).join(`
+`);
+        } else {
+          formatted = JSON.stringify(value);
+        }
+        return `  ${key}: ` + formatted.split(`
+`).map((line, i) => i === 0 ? line : nextIndent + line).join(`
+`);
+      });
+      return `{
+` + entries.join(`,
+`) + `
+` + baseIndent + "}";
+    }
+    return JSON.stringify(data);
+  }
+  toJSON(entries) {
+    return JSON.stringify(entries, null, 2);
+  }
+  toSummary(entries) {
+    if (entries.length === 0) {
+      return "No trace entries";
+    }
+    const functions = new Set(entries.map((e) => e.function));
+    const actions = entries.reduce((acc, e) => {
+      acc[e.action] = (acc[e.action] || 0) + 1;
+      return acc;
+    }, {});
+    let summary = `Trace Summary (${entries.length} entries)
+`;
+    summary += `Functions: ${[...functions].join(", ")}
+`;
+    summary += `Actions: ${Object.entries(actions).map(([k, v]) => `${k}=${v}`).join(", ")}`;
+    return summary;
+  }
+}
+// packages/core/src/env/debug/formatters/tree-formatter.ts
+var Colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m"
+};
+function color(text, colorCode) {
+  return `${colorCode}${text}${Colors.reset}`;
+}
+var CHARS = {
+  VERTICAL: "\u2502",
+  VERTICAL_CONNECTOR: "\u251C\u2500\u2500",
+  LAST_CONNECTOR: "\u2514\u2500\u2500",
+  SPACE: " ",
+  BAR: "\u2588",
+  EMPTY: "\u2591",
+  DASH: "\u2500"
+};
+
+class TreeFormatter {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      showPercent: true,
+      showTimeBar: false,
+      barWidth: 10,
+      ...options
+    };
+  }
+  colorByPercent(percent) {
+    if (percent >= 80)
+      return Colors.red;
+    if (percent >= 50)
+      return Colors.yellow;
+    if (percent >= 20)
+      return Colors.cyan;
+    return Colors.dim;
+  }
+  formatTree(node) {
+    const lines = [];
+    const totalDuration = node.durationMs || 0;
+    const percentBase = node.children.reduce((sum, c) => sum + (c.durationMs || 0), 0) || totalDuration;
+    lines.push(this.formatNode(node, totalDuration, percentBase, "", true, true));
+    this.formatChildren(node.children, "", lines, totalDuration, percentBase);
+    return lines.join(`
+`);
+  }
+  formatNode(node, totalDuration, percentBase, prefix, isLast, isRoot) {
+    const connector = isRoot ? "" : isLast ? CHARS.LAST_CONNECTOR : CHARS.VERTICAL_CONNECTOR;
+    const prefixStr = isRoot ? "" : prefix;
+    let line = `${prefixStr}${connector} ${node.function}`;
+    if (node.durationMs !== undefined) {
+      line += color(` (${this.formatDuration(node.durationMs)})`, Colors.dim);
+    }
+    if (this.options.showPercent && percentBase > 0 && node.durationMs !== undefined && node.function !== "(root)" && !isRoot) {
+      const percent = Math.round(node.durationMs / percentBase * 100);
+      const percentStr = ` [${percent}%]`;
+      line += color(percentStr, this.colorByPercent(percent));
+    }
+    if (this.options.showTimeBar && node.durationMs !== undefined && totalDuration > 0 && !isRoot) {
+      line += " " + this.renderTimeBar(node.durationMs, totalDuration);
+    }
+    return isRoot ? color(line, Colors.bold) : line;
+  }
+  formatChildren(children, prefix, lines, totalDuration, percentBase) {
+    children.forEach((child, index) => {
+      const isLast = index === children.length - 1;
+      const newPrefix = prefix + (isLast ? "    " : `${CHARS.VERTICAL}   `);
+      lines.push(this.formatNode(child, totalDuration, percentBase, prefix, isLast, false));
+      if (child.children.length > 0) {
+        this.formatChildren(child.children, newPrefix, lines, totalDuration, percentBase);
+      }
+    });
+  }
+  renderTimeBar(duration, total) {
+    const width = this.options.barWidth || 10;
+    const filledWidth = Math.round(duration / total * width);
+    const emptyWidth = width - filledWidth;
+    const bar = CHARS.BAR.repeat(filledWidth) + CHARS.EMPTY.repeat(emptyWidth);
+    return color(`[${bar}]`, Colors.dim);
+  }
+  formatDuration(ms) {
+    if (ms < 1000) {
+      return `${ms}ms`;
+    } else if (ms < 60000) {
+      return `${(ms / 1000).toFixed(2)}s`;
+    } else if (ms < 3600000) {
+      const mins = Math.floor(ms / 60000);
+      const secs = Math.round(ms % 60000 / 1000);
+      return `${mins}m ${secs}s`;
+    } else {
+      const hours = Math.floor(ms / 3600000);
+      const mins = Math.floor(ms % 3600000 / 60000);
+      return `${hours}h ${mins}m`;
+    }
+  }
+  formatTrees(trees) {
+    if (trees.length === 0) {
+      return "No trace trees";
+    }
+    return trees.map((tree) => this.formatTree(tree)).join(`
+
+`);
+  }
+  toJSON(trees) {
+    return JSON.stringify(trees, null, 2);
+  }
+  formatSummary(node) {
+    const rows = [];
+    const total = node.durationMs || 0;
+    const childrenTotal = node.children.reduce((sum, c) => sum + (c.durationMs || 0), 0);
+    const percentBase = total > 0 ? total : childrenTotal;
+    const collect = (n, depth) => {
+      if (n.durationMs !== undefined) {
+        rows.push({
+          func: n.function,
+          duration: n.durationMs,
+          percent: percentBase > 0 ? Math.round(n.durationMs / percentBase * 100) : 0,
+          depth
+        });
+      }
+      n.children.forEach((child) => collect(child, depth + 1));
+    };
+    collect(node, 0);
+    rows.sort((a, b) => b.duration - a.duration);
+    const lines = [];
+    lines.push(color(`
+=== Duration Summary ===`, Colors.bold));
+    lines.push(color(`(sorted by time consumption)
+`, Colors.dim));
+    lines.push(color(`  ${"\u2500".repeat(65)}`, Colors.dim));
+    lines.push(color(`  ${"FUNCTION".padEnd(35)} ${"TIME".padEnd(12)} %`, Colors.dim));
+    lines.push(color(`  ${"\u2500".repeat(65)}`, Colors.dim));
+    for (const row of rows) {
+      const indent = "  ".repeat(row.depth);
+      const funcDisplay = row.depth > 0 ? "\u2514\u2500 ".repeat(row.depth) + row.func : row.func;
+      const percentStr = String(row.percent).padStart(3) + "%";
+      const percentColor = row.percent >= 50 ? Colors.red : row.percent >= 20 ? Colors.yellow : Colors.dim;
+      lines.push(`  ${indent}${funcDisplay.substring(0, 35).padEnd(35)}${this.formatDuration(row.duration).padEnd(12)} ${color(percentStr, percentColor)}`);
+    }
+    return lines.join(`
+`);
+  }
+  formatTimeline(node) {
+    const lines = [];
+    const totalDuration = node.durationMs || 0;
+    lines.push(color(`
+=== Timeline: ${node.function} ===`, Colors.bold));
+    lines.push(color(`Total: ${this.formatDuration(totalDuration)}
+`, Colors.dim));
+    const timeline = this.buildTimeline(node, totalDuration, 0, 0);
+    lines.push(...timeline);
+    return lines.join(`
+`);
+  }
+  buildTimeline(node, totalDuration, absoluteOffset, depth) {
+    const lines = [];
+    const width = 40;
+    const startPos = Math.round(absoluteOffset / totalDuration * width);
+    const durationWidth = node.durationMs !== undefined ? Math.max(2, Math.round(node.durationMs / totalDuration * width)) : 2;
+    const bar = " ".repeat(Math.max(0, startPos)) + CHARS.BAR.repeat(durationWidth);
+    const indent = "  ".repeat(depth);
+    const funcName = node.function.length > 25 ? "..." + node.function.slice(-22) : node.function;
+    const time = node.durationMs !== undefined ? this.formatDuration(node.durationMs) : "-";
+    const percent = node.durationMs !== undefined ? ` [${Math.round(node.durationMs / totalDuration * 100)}%]` : "";
+    lines.push(`${indent}${funcName.padEnd(25)} ${bar} ${color(time + percent, Colors.dim)}`);
+    let childOffset = absoluteOffset;
+    for (const child of node.children) {
+      lines.push(...this.buildTimeline(child, totalDuration, childOffset, depth + 1));
+      childOffset += child.durationMs || 0;
+    }
+    return lines;
+  }
+}
+// packages/core/src/env/debug/formatters/repl-formatter.ts
+class ReplFormatter {
+  context = {};
+  history = [];
+  getWelcomeMessage() {
+    return `========================================
+  Debug REPL - Interactive Debugger
+========================================
+
+Commands:
+  list [limit]     - List trace IDs
+  trace [options]  - Show trace details
+  tree [options]   - Show call tree
+  help             - Show this help
+  exit             - Exit REPL
+
+Examples:
+  list 10
+  trace --func llm.invoke
+  tree --trace trace-001
+
+========================================
+`;
+  }
+  formatPrompt(context) {
+    const ctx = { ...this.context, ...context };
+    let prompt = "debug";
+    if (ctx.traceId) {
+      prompt += `:${ctx.traceId}`;
+    } else if (ctx.function) {
+      prompt += `:${ctx.function}`;
+    }
+    return `${prompt}> `;
+  }
+  getHelpText() {
+    return `
+Available Commands:
+==================
+list [n]              - List recent trace IDs (default: 10)
+trace [options]       - Show trace details
+  --func <name>       - Filter by function name
+  --trace <id>        - Show specific trace
+  --pretty            - Pretty print output
+  --limit <n>         - Limit results
+tree [options]        - Show call tree
+  --func <name>       - Show tree for function
+  --trace <id>        - Show tree for trace
+clear                 - Clear screen
+help                  - Show this help
+exit                  - Exit REPL
+`;
+  }
+  formatCommandResult(command, data) {
+    switch (command) {
+      case "list":
+        return this.formatListResult(data);
+      case "trace":
+        return this.formatTraceResult(data);
+      case "tree":
+        return this.formatTreeResult(data);
+      default:
+        return `Unknown command: ${command}`;
+    }
+  }
+  formatListResult(data) {
+    const { traceIds, count } = data;
+    if (traceIds.length === 0) {
+      return "No traces found.";
+    }
+    let output = `
+`;
+    output += `  TraceId            First Time              Count
+`;
+    output += "  " + "-".repeat(70) + `
+`;
+    for (const trace of traceIds) {
+      const time = trace.firstTime.replace("T", " ").substring(0, 19);
+      output += `  ${trace.traceId.padEnd(18)} ${time.padEnd(22)} ${trace.count}
+`;
+    }
+    output += `
+  Total: ${count} traces
+`;
+    return output;
+  }
+  formatTraceResult(entries) {
+    if (entries.length === 0) {
+      return "No traces found.";
+    }
+    let output = "";
+    let currentTraceId = null;
+    for (const entry of entries) {
+      if (entry.traceId !== currentTraceId) {
+        currentTraceId = entry.traceId;
+        output += `
+=== Trace: ${entry.traceId} ===
+
+`;
+      }
+      if (entry.action === "enter") {
+        output += `>>> ${entry.function} enter:`;
+        if (entry.params) {
+          output += `
+` + this.formatJsonCompact(entry.params);
+        }
+        output += `
+`;
+      } else if (entry.action === "quit") {
+        output += `<<< ${entry.function} quit`;
+        if (entry.durationMs !== undefined) {
+          output += ` (${entry.durationMs}ms)`;
+        }
+        if (entry.result) {
+          output += `:
+` + this.formatJsonCompact(entry.result);
+        }
+        output += `
+`;
+      } else if (entry.action === "error") {
+        output += `!!! ${entry.function} error: ${entry.error}
+`;
+      }
+    }
+    return output;
+  }
+  formatTreeResult(trees) {
+    if (trees.length === 0) {
+      return "No trees found.";
+    }
+    let output = "";
+    for (const tree of trees) {
+      output += this.formatTreeNode(tree, "");
+    }
+    return output;
+  }
+  formatTreeNode(node, prefix) {
+    const duration = node.durationMs !== undefined ? ` (${node.durationMs}ms)` : "";
+    let output = `${prefix}${node.function}${duration}
+`;
+    const childPrefix = prefix + "  ";
+    for (let i = 0;i < node.children.length; i++) {
+      const isLast = i === node.children.length - 1;
+      const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+      output += this.formatTreeNode(node.children[i], childPrefix + connector);
+    }
+    return output;
+  }
+  formatJsonCompact(data, indent = 2) {
+    const spaces = "  ".repeat(indent);
+    if (data === null || data === undefined) {
+      return `${spaces}null
+`;
+    }
+    if (typeof data === "string") {
+      if (data.length > 200) {
+        return `${spaces}"${data.substring(0, 200)}..."
+`;
+      }
+      return `${spaces}"${data}"
+`;
+    }
+    if (typeof data === "number" || typeof data === "boolean") {
+      return `${spaces}${data}
+`;
+    }
+    if (Array.isArray(data)) {
+      if (data.length === 0)
+        return `${spaces}[]
+`;
+      let output = `${spaces}[
+`;
+      for (const item of data) {
+        output += this.formatJsonCompact(item, indent + 1);
+      }
+      output += `${spaces}]
+`;
+      return output;
+    }
+    if (typeof data === "object") {
+      const entries = Object.entries(data);
+      if (entries.length === 0)
+        return `${spaces}{}
+`;
+      let output = `${spaces}{
+`;
+      for (const [key, val] of entries) {
+        output += `${spaces}  ${key}: ${JSON.stringify(val).substring(0, 50)}`;
+        if (JSON.stringify(val).length > 50) {
+          output += "...";
+        }
+        output += `
+`;
+      }
+      output += `${spaces}}
+`;
+      return output;
+    }
+    return `${spaces}${String(data)}
+`;
+  }
+  parseCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      return { command: "help", args: {} };
+    }
+    if (["exit", "quit", "q"].includes(trimmed.toLowerCase())) {
+      return { command: "exit", args: {} };
+    }
+    if (trimmed.toLowerCase() === "clear") {
+      return { command: "clear", args: {} };
+    }
+    if (["help", "?", "h"].includes(trimmed.toLowerCase())) {
+      return { command: "help", args: {} };
+    }
+    const parts = trimmed.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+    if (parts.length === 0) {
+      return { command: "help", args: {} };
+    }
+    const command = parts[0]?.toLowerCase() ?? "";
+    const args = {};
+    for (let i = 1;i < parts.length; i++) {
+      const part = parts[i];
+      if (part.startsWith("--")) {
+        const key = part.substring(2);
+        const next = parts[i + 1];
+        if (next && !next.startsWith("--")) {
+          args[key] = next;
+          i++;
+        } else {
+          args[key] = "true";
+        }
+      } else if (part.startsWith("-")) {
+        const key = part.substring(1);
+        const next = parts[i + 1];
+        if (next && !next.startsWith("-")) {
+          args[key] = next;
+          i++;
+        } else {
+          args[key] = "true";
+        }
+      } else {
+        if (command === "list" && !args.limit) {
+          args.limit = part;
+        } else if (command === "trace" && !args.func) {
+          args.func = part;
+        } else if (command === "tree" && !args.func) {
+          args.func = part;
+        }
+      }
+    }
+    return { command, args };
+  }
+  setContext(context) {
+    this.context = { ...this.context, ...context };
+  }
+  getContext() {
+    return { ...this.context };
+  }
+  addToHistory(command) {
+    if (command.trim() && this.history[this.history.length - 1] !== command) {
+      this.history.push(command);
+    }
+  }
+  getHistory() {
+    return [...this.history];
+  }
+}
+// packages/core/src/env/component.ts
+class BaseComponent {
+  _status = "created";
+  _enabled = true;
+  env;
+  hookManager;
+  constructor() {
+    this.hookManager = new HookManager;
+  }
+  getStatus() {
+    return this._status;
+  }
+  getConfig() {
+    return {
+      name: this.name,
+      version: this.version,
+      enabled: this._enabled,
+      env: this.env
+    };
+  }
+  isEnvInitialized() {
+    return this._status !== "created";
+  }
+  setStatus(status) {
+    this._status = status;
+  }
+  getEnv() {
+    return this.env;
+  }
+  async init(config) {
+    if (config?.env) {
+      this.env = config.env;
+    }
+    this.setStatus("initializing");
+    try {
+      if (config?.name)
+        Object.defineProperty(this, "name", { value: config.name, writable: false });
+      if (config?.version)
+        Object.defineProperty(this, "version", { value: config.version, writable: false });
+    } catch {}
+    if (config?.enabled !== undefined)
+      this._enabled = config.enabled;
+    this.hookManager.setComponentInfo(this.name, this.version);
+    await this.onInit();
+    this.setStatus("running");
+  }
+  async start() {
+    if (this._started)
+      return;
+    this._started = true;
+    await this.onStart();
+    this.setStatus("running");
+  }
+  async stop() {
+    this.setStatus("stopping");
+    this.hookManager.clear();
+    await this.onStop();
+    this.setStatus("stopped");
+  }
+  async onInit() {}
+  async onStart() {}
+  async onStop() {}
+  registerHook(hookPoint, hook) {
+    this.hookManager.register(hookPoint, hook);
+  }
+  addHook(hookPoint, name, fn, priority) {
+    this.hookManager.register(hookPoint, createHook({ name, priority }, fn));
+  }
+  removeHook(hookPoint, name) {
+    return this.hookManager.unregister(hookPoint, name);
+  }
+  async executeHooks(hookPoint, data, metadata) {
+    await this.hookManager.execute(hookPoint, data, metadata);
+  }
+  getConfigComponent() {
+    return this.env?.getComponent("config");
+  }
+  getRuntimeConfig(key, defaultValue) {
+    const configComponent = this.getConfigComponent();
+    if (configComponent) {
+      const value = configComponent.get(key);
+      if (value !== undefined) {
+        return value;
+      }
+    }
+    return defaultValue;
+  }
+}
+
+// packages/core/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);
+  }
+}
+
+// packages/core/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: SQLiteSpanStorage2 } = await Promise.resolve().then(() => exports_span_storage);
+      this.storage = new SQLiteSpanStorage2(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;
+    }
+  }
+}
+
+// packages/core/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;
+  }
+}
+
+// packages/core/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;
+  }
+}
+
+// packages/core/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: getTracerProvider2 } = await Promise.resolve().then(() => (init_tracer_provider(), exports_tracer_provider));
+      const provider = getTracerProvider2();
+      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: getTracerProvider2 } = await Promise.resolve().then(() => (init_tracer_provider(), exports_tracer_provider));
+      const provider = getTracerProvider2();
+      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: getTracerProvider2 } = await Promise.resolve().then(() => (init_tracer_provider(), exports_tracer_provider));
+      const provider = getTracerProvider2();
+      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 {
+  TreeFormatter,
+  TraceFormatter,
+  SpanDbReader,
+  SpanBuilder,
+  ReplFormatter,
+  RegexParser,
+  LogReader,
+  DebugComponent
+};