agent-inspect 1.3.0 → 1.5.0

package/packages/core/dist/chunk-QPAU2TPA.mjs

@@ -0,0 +1,785 @@
+import { nanoid } from './chunk-7TGZLWEE.mjs';
+import { TreeBuilder } from './chunk-E5F2LQCX.mjs';
+import { Redactor } from './chunk-VU6O5QAH.mjs';
+import { readFile } from 'fs/promises';
+
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isNonEmptyStringArray(v) {
+  return Array.isArray(v) && v.length > 0 && v.every((x) => typeof x === "string" && x.trim() !== "");
+}
+function validateRedact(redact) {
+  if (!Array.isArray(redact)) {
+    throw new Error("Invalid config: redact must be an array");
+  }
+  for (const r of redact) {
+    if (typeof r === "string") continue;
+    if (!isRecord(r)) {
+      throw new Error("Invalid config: redact entries must be strings or objects");
+    }
+    if (typeof r.key !== "string" || r.key.trim() === "") {
+      throw new Error("Invalid config: redact.key must be a non-empty string");
+    }
+    if (r.strategy !== "full" && r.strategy !== "prefix" && r.strategy !== "hash") {
+      throw new Error(
+        `Invalid config: redact.strategy must be one of full, prefix, hash (got ${String(
+          r.strategy
+        )})`
+      );
+    }
+    if (r.keep !== void 0 && (typeof r.keep !== "number" || !Number.isFinite(r.keep) || r.keep < 0)) {
+      throw new Error("Invalid config: redact.keep must be a non-negative number when provided");
+    }
+  }
+}
+function validateMappings(mappings) {
+  if (!isRecord(mappings)) {
+    throw new Error("Invalid config: mappings must be an object");
+  }
+}
+var DEFAULT_LOG_INGEST_CONFIG = {
+  runIdKeys: ["runId", "traceId", "requestId", "decisionId", "jobId"],
+  eventKey: "event",
+  timestampKey: "timestamp",
+  messageKey: "message",
+  levelKey: "level",
+  heuristicWindowMs: 2e3,
+  mappings: {
+    "*.error": { kind: "ERROR", status: "error" },
+    "*.failed": { kind: "ERROR", status: "error" },
+    "*.llm.*": { kind: "LLM" },
+    "*.tool.*": { kind: "TOOL" },
+    "*.agent.*": { kind: "AGENT" },
+    "*.retriever.*": { kind: "RETRIEVER" },
+    "*.result.*": { kind: "RESULT" }
+  }
+};
+function mergeLogIngestConfig(base, override) {
+  const merged = {
+    ...base,
+    ...override,
+    mappings: {
+      ...base.mappings ?? {},
+      ...override.mappings ?? {}
+    }
+  };
+  return merged;
+}
+async function loadLogIngestConfig(configPath) {
+  if (configPath === void 0 || configPath.trim() === "") {
+    return DEFAULT_LOG_INGEST_CONFIG;
+  }
+  let rawText;
+  try {
+    rawText = await readFile(configPath, "utf-8");
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`Failed to read config file: ${configPath} (${msg})`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawText);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`Invalid JSON in config file: ${configPath} (${msg})`);
+  }
+  if (!isRecord(parsed)) {
+    throw new Error("Invalid config: expected a JSON object at top-level");
+  }
+  const user = parsed;
+  if (user.runIdKeys !== void 0 && !isNonEmptyStringArray(user.runIdKeys)) {
+    throw new Error("Invalid config: runIdKeys must be a non-empty array of strings");
+  }
+  if (user.eventKey !== void 0 && (typeof user.eventKey !== "string" || user.eventKey.trim() === "")) {
+    throw new Error("Invalid config: eventKey must be a non-empty string");
+  }
+  for (const k of [
+    "timestampKey",
+    "messageKey",
+    "levelKey",
+    "parentIdKey",
+    "durationKey",
+    "statusKey"
+  ]) {
+    const v = user[k];
+    if (v !== void 0 && (typeof v !== "string" || v.trim() === "")) {
+      throw new Error(`Invalid config: ${k} must be a non-empty string when provided`);
+    }
+  }
+  if (user.mappings !== void 0) {
+    validateMappings(user.mappings);
+  }
+  if (user.redact !== void 0) {
+    validateRedact(user.redact);
+  }
+  if (user.heuristicWindowMs !== void 0 && (typeof user.heuristicWindowMs !== "number" || !Number.isFinite(user.heuristicWindowMs) || user.heuristicWindowMs < 0)) {
+    throw new Error("Invalid config: heuristicWindowMs must be a non-negative number when provided");
+  }
+  if (user.redact && JSON.stringify(user.redact).includes("=>")) {
+    throw new Error("Invalid config: function strings are not supported in redact rules");
+  }
+  return mergeLogIngestConfig(DEFAULT_LOG_INGEST_CONFIG, user);
+}
+function isRecord2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var JsonLogParser = class {
+  parseLines(lines, filePath) {
+    const records = [];
+    const warnings = [];
+    for (let i = 0; i < lines.length; i++) {
+      const lineNumber = i + 1;
+      const raw = lines[i] ?? "";
+      const trimmed = raw.trim();
+      if (trimmed === "") continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        warnings.push({
+          code: "MALFORMED_JSON",
+          message: "Malformed JSON log line",
+          file: filePath,
+          line: lineNumber,
+          raw: trimmed.slice(0, 500)
+        });
+        continue;
+      }
+      if (!isRecord2(parsed)) {
+        warnings.push({
+          code: "MALFORMED_JSON",
+          message: "JSON log line must be an object",
+          file: filePath,
+          line: lineNumber,
+          raw: trimmed.slice(0, 500)
+        });
+        continue;
+      }
+      records.push({
+        raw: parsed,
+        file: filePath,
+        line: lineNumber,
+        sourceType: "json-log"
+      });
+    }
+    return { records, warnings };
+  }
+  async parseFile(filePath) {
+    let text;
+    try {
+      text = await readFile(filePath, "utf-8");
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new Error(`Failed to read log file: ${filePath} (${msg})`);
+    }
+    const lines = text.split(/\r?\n/);
+    return this.parseLines(lines, filePath);
+  }
+};
+function isRecord3(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function findLastJsonObjectSubstring(line) {
+  let last;
+  for (let i = 0; i < line.length; i++) {
+    if (line[i] !== "{") continue;
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let j = i; j < line.length; j++) {
+      const ch = line[j];
+      if (inString) {
+        if (escape) {
+          escape = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escape = true;
+          continue;
+        }
+        if (ch === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (ch === '"') {
+        inString = true;
+        continue;
+      }
+      if (ch === "{") depth += 1;
+      if (ch === "}") depth -= 1;
+      if (depth === 0) {
+        last = { start: i, end: j + 1 };
+        i = j;
+        break;
+      }
+      if (depth < 0) break;
+    }
+  }
+  if (!last) return void 0;
+  return line.slice(last.start, last.end);
+}
+var Log4jsParser = class {
+  parseLines(lines, filePath) {
+    const records = [];
+    const warnings = [];
+    for (let i = 0; i < lines.length; i++) {
+      const lineNumber = i + 1;
+      const rawLine = lines[i] ?? "";
+      const trimmed = rawLine.trim();
+      if (trimmed === "") continue;
+      const jsonText = findLastJsonObjectSubstring(trimmed);
+      if (!jsonText) {
+        warnings.push({
+          code: "UNSUPPORTED_LOG4JS_PAYLOAD",
+          message: "No embedded JSON object found in log4js line",
+          file: filePath,
+          line: lineNumber,
+          raw: trimmed.slice(0, 500)
+        });
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(jsonText);
+      } catch {
+        warnings.push({
+          code: "MALFORMED_JSON",
+          message: "Malformed embedded JSON object in log4js line",
+          file: filePath,
+          line: lineNumber,
+          raw: jsonText.slice(0, 500)
+        });
+        continue;
+      }
+      if (!isRecord3(parsed)) {
+        warnings.push({
+          code: "UNSUPPORTED_LOG4JS_PAYLOAD",
+          message: "Embedded JSON payload must be an object",
+          file: filePath,
+          line: lineNumber,
+          raw: jsonText.slice(0, 500)
+        });
+        continue;
+      }
+      records.push({
+        raw: parsed,
+        file: filePath,
+        line: lineNumber,
+        sourceType: "log4js"
+      });
+    }
+    return { records, warnings };
+  }
+  async parseFile(filePath) {
+    let text;
+    try {
+      text = await readFile(filePath, "utf-8");
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new Error(`Failed to read log file: ${filePath} (${msg})`);
+    }
+    const lines = text.split(/\r?\n/);
+    return this.parseLines(lines, filePath);
+  }
+};
+
+// packages/core/src/logs/mapping.ts
+function wildcardMatch(pattern, value) {
+  if (pattern === value) return true;
+  if (!pattern.includes("*")) return false;
+  const parts = pattern.split("*");
+  let idx = 0;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === "") continue;
+    const found = value.indexOf(part, idx);
+    if (found === -1) return false;
+    if (i === 0 && !pattern.startsWith("*") && found !== 0) return false;
+    idx = found + part.length;
+  }
+  if (!pattern.endsWith("*")) {
+    const last = parts[parts.length - 1];
+    if (last !== "" && !value.endsWith(last)) return false;
+    if (last === "" && !value.endsWith(parts[parts.length - 2] ?? "")) return false;
+  }
+  return true;
+}
+function matchMapping(eventName, mappings) {
+  if (!mappings) return void 0;
+  if (mappings[eventName]) return mappings[eventName];
+  let bestKey;
+  let bestScore = -1;
+  for (const key of Object.keys(mappings)) {
+    if (!key.includes("*")) continue;
+    if (!wildcardMatch(key, eventName)) continue;
+    const score = key.replaceAll("*", "").length;
+    if (score > bestScore) {
+      bestScore = score;
+      bestKey = key;
+    }
+  }
+  return bestKey ? mappings[bestKey] : void 0;
+}
+
+// packages/core/src/logs/normalizer.ts
+function isFiniteNumber(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function safeString(v) {
+  if (typeof v !== "string") return void 0;
+  const t = v.trim();
+  return t === "" ? void 0 : t;
+}
+function parseTimestamp(v) {
+  if (isFiniteNumber(v)) return v;
+  if (typeof v === "string") {
+    const t = Date.parse(v);
+    if (Number.isFinite(t)) return t;
+  }
+  return void 0;
+}
+function hasToken(hay, token) {
+  return hay.includes(token);
+}
+function inferKind(eventName) {
+  if (hasToken(eventName, ".llm.")) return "LLM";
+  if (hasToken(eventName, ".tool.")) return "TOOL";
+  if (hasToken(eventName, ".agent.")) return "AGENT";
+  if (hasToken(eventName, ".retriever.")) return "RETRIEVER";
+  if (hasToken(eventName, ".result.")) return "RESULT";
+  if (eventName.endsWith(".error") || eventName.endsWith(".failed") || eventName.includes(".error") || eventName.includes(".failed")) {
+    return "ERROR";
+  }
+  return "LOG";
+}
+function deriveName(eventName, kind) {
+  const parts = eventName.split(".");
+  const last = parts[parts.length - 1] ?? eventName;
+  if (kind === "LLM") return `llm:${last}`;
+  if (kind === "TOOL") return `tool:${last}`;
+  if (kind === "AGENT") return `agent:${last}`;
+  if (kind === "RESULT") return `result:${last}`;
+  if (kind === "RUN") return `run:${last}`;
+  if (kind === "RETRIEVER") return `retriever:${last}`;
+  if (kind === "ERROR") return `error:${last}`;
+  return eventName;
+}
+var EventNormalizer = class {
+  #config;
+  constructor(options) {
+    this.#config = options.config;
+  }
+  #normalizeInternal(record) {
+    const raw = record.raw;
+    const cfg = this.#config;
+    let runId;
+    for (const k of cfg.runIdKeys) {
+      const v = raw[k];
+      const s = safeString(v);
+      if (s) {
+        runId = s;
+        break;
+      }
+    }
+    if (!runId) {
+      return {
+        warning: {
+          code: "MISSING_RUN_ID",
+          message: "Missing run id (none of runIdKeys present)",
+          file: record.file,
+          line: record.line
+        }
+      };
+    }
+    const eventName = safeString(raw[cfg.eventKey]);
+    if (!eventName) {
+      return {
+        warning: {
+          code: "MISSING_EVENT",
+          message: `Missing event name (key: ${cfg.eventKey})`,
+          file: record.file,
+          line: record.line
+        }
+      };
+    }
+    const mapping = matchMapping(eventName, cfg.mappings);
+    const tsKey = cfg.timestampKey ?? "timestamp";
+    const tsRaw = raw[tsKey];
+    const parsedTs = parseTimestamp(tsRaw);
+    const timestamp = parsedTs ?? Date.now();
+    const timestampMissing = parsedTs === void 0;
+    const parentIdKey = cfg.parentIdKey;
+    const parentId = parentIdKey ? safeString(raw[parentIdKey]) : void 0;
+    let durationMs;
+    const durationKey = cfg.durationKey;
+    if (durationKey) {
+      const v = raw[durationKey];
+      if (isFiniteNumber(v)) durationMs = v;
+    } else if (isFiniteNumber(raw.durationMs)) {
+      durationMs = raw.durationMs;
+    }
+    let status;
+    const statusKey = cfg.statusKey;
+    const statusRaw = statusKey ? safeString(raw[statusKey]) : void 0;
+    if (statusRaw === "running" || statusRaw === "ok" || statusRaw === "error") {
+      status = statusRaw;
+    } else if (mapping?.status) {
+      status = mapping.status;
+    } else if (mapping?.kind === "ERROR") {
+      status = "error";
+    } else if (eventName.includes(".failed") || eventName.includes(".error")) {
+      status = "error";
+    } else if (mapping?.startsRun || mapping?.startsStep) {
+      status = "running";
+    } else if (mapping?.endsRun || mapping?.endsStep) {
+      status = "ok";
+    }
+    const kind = mapping?.kind ?? inferKind(eventName);
+    const name = mapping?.name ?? deriveName(eventName, kind);
+    let confidence = "correlated";
+    if (parentId || mapping?.startsRun) confidence = "explicit";
+    if (timestampMissing) confidence = "unknown";
+    const omit = new Set([
+      ...cfg.runIdKeys,
+      cfg.eventKey,
+      tsKey,
+      cfg.messageKey ?? "message",
+      cfg.levelKey ?? "level",
+      cfg.parentIdKey ?? "",
+      cfg.durationKey ?? "",
+      cfg.statusKey ?? "",
+      "durationMs"
+    ].filter((k) => k !== ""));
+    const attributes = {};
+    for (const [k, v] of Object.entries(raw)) {
+      if (omit.has(k)) continue;
+      attributes[k] = v;
+    }
+    const event = {
+      eventId: nanoid(10),
+      runId,
+      ...parentId ? { parentId } : {},
+      name,
+      kind,
+      timestamp,
+      ...status ? { status } : {},
+      ...durationMs !== void 0 ? { durationMs } : {},
+      ...Object.keys(attributes).length > 0 ? { attributes } : {},
+      confidence,
+      source: {
+        type: record.sourceType,
+        file: record.file,
+        line: record.line
+      }
+    };
+    if (timestampMissing) {
+      return {
+        event,
+        warning: {
+          code: "MISSING_TIMESTAMP",
+          message: `Missing or invalid timestamp (key: ${tsKey})`,
+          file: record.file,
+          line: record.line,
+          raw: JSON.stringify(raw).slice(0, 500)
+        }
+      };
+    }
+    return { event };
+  }
+  normalize(record) {
+    const r = this.#normalizeInternal(record);
+    return r.event ?? r.warning;
+  }
+  normalizeAll(records) {
+    const out = [];
+    const warnings = [];
+    for (const r of records) {
+      const normalized = this.#normalizeInternal(r);
+      if (normalized.event) out.push(normalized.event);
+      if (normalized.warning) warnings.push(normalized.warning);
+    }
+    return { records: out, warnings };
+  }
+};
+
+// packages/core/src/logs/tree-renderer.ts
+function truncate(v, max) {
+  if (v.length <= max) return v;
+  return v.slice(0, Math.max(0, max - 1)) + "\u2026";
+}
+function fmtAttrValue(value, maxLen) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "string") return truncate(value, maxLen);
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (typeof value === "object") {
+    try {
+      return truncate(JSON.stringify(value), maxLen);
+    } catch {
+      return "[object]";
+    }
+  }
+  return String(value);
+}
+function compactAttrs(attrs, maxLen) {
+  if (!attrs) return "";
+  const entries = Object.entries(attrs);
+  if (entries.length === 0) return "";
+  const picks = /* @__PURE__ */ new Map();
+  const set = (k, v) => {
+    const s = fmtAttrValue(v, maxLen);
+    if (s !== void 0) picks.set(k, s);
+  };
+  set("job", attrs.jobId ?? attrs.job ?? attrs.jobUuid);
+  set("user", attrs.userUuid ?? attrs.userId ?? attrs.user);
+  set("trip", attrs.tripUuid ?? attrs.tripId ?? attrs.trip);
+  set("msgs", attrs.messageCount ?? attrs.msgs);
+  set("trips", attrs.trips);
+  set("model", attrs.model);
+  const tokens = attrs.tokens;
+  if (tokens && typeof tokens === "object" && tokens !== null) {
+    const input = tokens.input;
+    const output = tokens.output;
+    if (typeof input === "number" || typeof output === "number") {
+      picks.set("tokens", `${input ?? "?"}/${output ?? "?"}`);
+    }
+  }
+  for (const k of ["shouldNotify", "variant"]) {
+    if (k in attrs) set(k, attrs[k]);
+  }
+  const rendered = [...picks.entries()].filter(([, v]) => v !== "").map(([k, v]) => `${k}=${v}`);
+  return rendered.length > 0 ? " " + rendered.join(" ") : "";
+}
+function statusMark(node) {
+  if (node.event.status === "error") return " \u2716";
+  if (node.event.status === "ok") return " \u2714";
+  return "";
+}
+function fmtDuration(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "";
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+function renderNodeLines(node, prefix, isLast, options) {
+  const branch = prefix + (isLast ? "\u2514\u2500 " : "\u251C\u2500 ");
+  const nextPrefix = prefix + (isLast ? "   " : "\u2502  ");
+  const attrs = compactAttrs(node.event.attributes, options.maxAttributeLength);
+  const dur = node.event.durationMs !== void 0 ? ` ${fmtDuration(node.event.durationMs)}` : "";
+  const line = `${branch}${node.event.name}${attrs}${statusMark(node)}${dur}`;
+  const lines = [line];
+  const showConf = options.showConfidence === "always" || options.showConfidence === "non-explicit" && node.event.confidence !== "explicit";
+  if (showConf) {
+    lines.push(`${nextPrefix}confidence: ${node.event.confidence}`);
+  }
+  const children = node.children;
+  for (let i = 0; i < children.length; i++) {
+    lines.push(...renderNodeLines(children[i], nextPrefix, i === children.length - 1, options));
+  }
+  return lines;
+}
+function renderRunTree(tree, options) {
+  const opts = {
+    verbose: options?.verbose ?? false,
+    showConfidence: options?.showConfidence ?? "always",
+    showMetadata: options?.showMetadata ?? false,
+    color: options?.color ?? false,
+    maxAttributeLength: options?.maxAttributeLength ?? 40,
+    summary: options?.summary ?? true
+  };
+  const header = `Run ${tree.runId}`;
+  const lines = [header];
+  const children = tree.children;
+  for (let i = 0; i < children.length; i++) {
+    lines.push(...renderNodeLines(children[i], "", i === children.length - 1, opts));
+  }
+  if (opts.summary) {
+    const cb = tree.metadata.confidenceBreakdown;
+    const tools = tree.metadata.kinds.TOOL ?? 0;
+    const llms = tree.metadata.kinds.LLM ?? 0;
+    lines.push("");
+    lines.push("Summary:");
+    lines.push(`  Events: ${tree.metadata.totalEvents}`);
+    lines.push(`  Tools: ${tools}`);
+    lines.push(`  LLMs: ${llms}`);
+    lines.push(
+      `  Confidence: ${cb.explicit} explicit, ${cb.correlated} correlated, ${cb.heuristic} heuristic, ${cb.unknown} unknown`
+    );
+    lines.push("");
+    lines.push("Note:");
+    lines.push("  Flat timeline by default. Nesting only with explicit parentId.");
+  }
+  return lines.join("\n");
+}
+function renderRunTrees(trees, options) {
+  return trees.map((t) => renderRunTree(t, options)).join("\n\n");
+}
+
+// packages/core/src/logs/line-parser.ts
+function shiftLineNumbers(res, options) {
+  const targetLine = typeof options.line === "number" && Number.isFinite(options.line) && options.line > 0 ? Math.floor(options.line) : void 0;
+  const file = typeof options.file === "string" && options.file.trim() !== "" ? options.file : void 0;
+  if (targetLine === void 0 && file === void 0) return res;
+  const mapRecord = (x) => ({
+    ...x,
+    ...targetLine !== void 0 ? { line: targetLine } : {},
+    ...file !== void 0 ? { file } : {}
+  });
+  const mapWarning = (x) => ({
+    ...x,
+    ...targetLine !== void 0 ? { line: targetLine } : {},
+    ...file !== void 0 ? { file } : {}
+  });
+  return {
+    records: res.records.map(mapRecord),
+    warnings: res.warnings.map(mapWarning)
+  };
+}
+function normalizeFormat(line, format) {
+  if (format && format !== "auto") return format;
+  const trimmed = line.trim();
+  if (trimmed.startsWith("{")) return "json";
+  return "log4js";
+}
+function parseLogLine(line, options = {}) {
+  const raw = typeof line === "string" ? line : "";
+  const trimmed = raw.trim();
+  if (trimmed === "") return { records: [], warnings: [] };
+  const format = normalizeFormat(raw, options.format);
+  const base = format === "json" ? new JsonLogParser().parseLines([raw], options.file) : new Log4jsParser().parseLines([raw], options.file);
+  return shiftLineNumbers(base, options);
+}
+
+// packages/core/src/logs/live-tree.ts
+var LiveLogAccumulator = class {
+  #config;
+  #format;
+  #file;
+  #normalizer;
+  #redactor;
+  #treeBuilder;
+  #events = [];
+  #warnings = [];
+  #trees = [];
+  constructor(options) {
+    this.#config = mergeLogIngestConfig(options.config, {});
+    this.#format = options.format ?? "auto";
+    this.#file = options.file;
+    this.#normalizer = new EventNormalizer({ config: this.#config });
+    this.#redactor = new Redactor({ rules: this.#config.redact });
+    this.#treeBuilder = new TreeBuilder({ config: this.#config });
+  }
+  pushLine(line, lineNumber) {
+    try {
+      const parsed = parseLogLine(line, {
+        format: this.#format,
+        file: this.#file,
+        line: lineNumber
+      });
+      const normalized = this.#normalizer.normalizeAll(parsed.records);
+      const redactedEvents = normalized.records.map((e) => ({
+        ...e,
+        attributes: e.attributes ? this.#redactor.redactRecord(e.attributes) : void 0
+      }));
+      this.#events = [...this.#events, ...redactedEvents];
+      this.#warnings = [...this.#warnings, ...parsed.warnings, ...normalized.warnings];
+      this.#trees = this.#treeBuilder.build(this.#events);
+      return {
+        events: this.#events,
+        trees: this.#trees,
+        warnings: this.#warnings
+      };
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      const warning = {
+        code: "UNKNOWN",
+        message: `LiveLogAccumulator failed to process line (${msg})`,
+        file: this.#file,
+        line: lineNumber,
+        raw: typeof line === "string" ? line.slice(0, 500) : void 0
+      };
+      this.#warnings = [...this.#warnings, warning];
+      return { events: this.#events, trees: this.#trees, warnings: this.#warnings };
+    }
+  }
+  getEvents() {
+    return this.#events;
+  }
+  getTrees() {
+    return this.#trees;
+  }
+  getWarnings() {
+    return this.#warnings;
+  }
+  reset() {
+    this.#events = [];
+    this.#trees = [];
+    this.#warnings = [];
+  }
+};
+function firstNonEmptyLine(text) {
+  for (const line of text.split(/\r?\n/)) {
+    const t = line.trim();
+    if (t !== "") return t;
+  }
+  return void 0;
+}
+async function detectFormat(filePath) {
+  const text = await readFile(filePath, "utf-8");
+  const first = firstNonEmptyLine(text);
+  if (!first) return "log4js";
+  if (!first.startsWith("{")) return "log4js";
+  try {
+    const parsed = JSON.parse(first);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return "json";
+  } catch {
+  }
+  return "log4js";
+}
+function applyOverrides(cfg, options) {
+  const override = {};
+  for (const k of [
+    "runIdKeys",
+    "eventKey",
+    "timestampKey",
+    "messageKey",
+    "levelKey",
+    "parentIdKey",
+    "durationKey",
+    "statusKey"
+  ]) {
+    const v = options[k];
+    if (v !== void 0) override[k] = v;
+  }
+  return mergeLogIngestConfig(cfg, override);
+}
+async function parseLogsToTrees(filePath, options = {}) {
+  const base = options.config ?? await loadLogIngestConfig(options.configPath);
+  const config = applyOverrides(base, options);
+  const format = options.format === "auto" || options.format === void 0 ? await detectFormat(filePath) : options.format;
+  let parsed;
+  if (format === "json") {
+    parsed = await new JsonLogParser().parseFile(filePath);
+  } else {
+    parsed = await new Log4jsParser().parseFile(filePath);
+  }
+  const normalizer = new EventNormalizer({ config });
+  const normalized = normalizer.normalizeAll(parsed.records);
+  const redactor = new Redactor({ rules: config.redact });
+  const events = normalized.records.map((e) => ({
+    ...e,
+    attributes: e.attributes ? redactor.redactRecord(e.attributes) : void 0
+  }));
+  const trees = new TreeBuilder({ config }).build(events);
+  return {
+    events,
+    trees,
+    warnings: [...parsed.warnings, ...normalized.warnings]
+  };
+}
+
+export { DEFAULT_LOG_INGEST_CONFIG, EventNormalizer, JsonLogParser, LiveLogAccumulator, Log4jsParser, loadLogIngestConfig, matchMapping, mergeLogIngestConfig, parseLogLine, parseLogsToTrees, renderRunTree, renderRunTrees, wildcardMatch };
+//# sourceMappingURL=chunk-QPAU2TPA.mjs.map
+//# sourceMappingURL=chunk-QPAU2TPA.mjs.map