omp-fabric 0.85.0

package/dist/chunks/chunk-HDJBUXDX.js

@@ -0,0 +1,1102 @@
+import {
+  clip,
+  compactRedactedValue,
+  contentText,
+  messageError,
+  recordOf,
+  redact,
+  redactRecord,
+  terminalSafe,
+  unwrapActorEnvelopeText
+} from "./chunk-DLXPTBPL.js";
+import {
+  readJsonlPageFromDescriptor
+} from "./chunk-UOSJZXJV.js";
+
+// src/core/call-preview.ts
+var HEADLINE_ARG_KEYS = [
+  "task",
+  "path",
+  "query",
+  "message",
+  "search",
+  "pattern",
+  "command",
+  "text",
+  "prompt",
+  "question",
+  "input",
+  "content",
+  "expression",
+  "url",
+  "topic",
+  "key",
+  "filter",
+  "name",
+  "q"
+];
+var HEADLINE_SKIP_KEYS = /* @__PURE__ */ new Set([
+  "label",
+  "title",
+  "type",
+  "kind",
+  "mode",
+  "format",
+  "resultFormat",
+  "limit",
+  "max",
+  "offset",
+  "start",
+  "concurrency",
+  "overwrite",
+  "id",
+  "provider",
+  "namespace",
+  "server",
+  "tool",
+  "ref",
+  "recursive",
+  "synthesize",
+  "commandDigest"
+]);
+var cleanOneLine = (value, max) => {
+  const single = value.replace(/\s+/g, " ").trim();
+  if (!single) return "";
+  return single.length <= max ? single : `${single.slice(0, Math.max(1, max - 1))}\u2026`;
+};
+var headlineArg = (args, max = 96) => {
+  if (!args) return void 0;
+  for (const key of HEADLINE_ARG_KEYS) {
+    const value = args[key];
+    if (typeof value === "string") {
+      const cleaned = cleanOneLine(value, max);
+      if (cleaned) return cleaned;
+    }
+  }
+  for (const [key, value] of Object.entries(args)) {
+    if (HEADLINE_SKIP_KEYS.has(key)) continue;
+    if (typeof value === "string") {
+      const cleaned = cleanOneLine(value, max);
+      if (cleaned) return cleaned;
+    }
+  }
+  return void 0;
+};
+
+// src/ui/preview-lines.ts
+function countContentLines(content) {
+  if (!content) return 0;
+  let terminators = 0;
+  for (let index = 0; index < content.length; index++) {
+    const code = content.charCodeAt(index);
+    if (code === 13) {
+      terminators++;
+      if (content.charCodeAt(index + 1) === 10) index++;
+    } else if (code === 10) {
+      terminators++;
+    }
+  }
+  const finalCode = content.charCodeAt(content.length - 1);
+  return terminators + (finalCode === 10 || finalCode === 13 ? 0 : 1);
+}
+function selectPreviewTextLines(text, limit) {
+  if (!Number.isInteger(limit)) {
+    const lines = collectPreviewTextLines(text);
+    return { ...selectPreviewLines(lines, limit), total: lines.length };
+  }
+  const entries = [];
+  const split = limit >= 8;
+  const head = split ? Math.ceil(limit * 0.65) : limit;
+  const tailLimit = split ? Math.max(1, limit - head - 1) : 0;
+  const tail = [];
+  let tailSize = 0;
+  let tailCursor = 0;
+  let total = 0;
+  forEachPreviewTextLine(text, (line, index) => {
+    total++;
+    if (limit <= 0 || index < limit) entries.push({ kind: "line", line, index });
+    if (!split || index < head) return;
+    tail[tailCursor] = line;
+    if (++tailCursor === tailLimit) tailCursor = 0;
+    if (tailSize < tailLimit) tailSize++;
+  });
+  if (limit <= 0 || total <= limit) return { entries, shown: total, hidden: 0, total };
+  if (!split) return { entries, shown: limit, hidden: total - limit, total };
+  const hidden = total - head - tailLimit;
+  const selected = entries.slice(0, head);
+  selected.push({ kind: "hidden", hidden });
+  let tailSlot = tailSize === tailLimit ? tailCursor : 0;
+  for (let offset = 0; offset < tailSize; offset++) {
+    const line = tail[tailSlot];
+    if (line === void 0) throw new RangeError(`Missing preview tail line ${offset}`);
+    selected.push({ kind: "line", line, index: total - tailSize + offset });
+    if (++tailSlot === tailLimit) tailSlot = 0;
+  }
+  return { entries: selected, shown: head + tailLimit, hidden, total };
+}
+function selectPreviewLines(lines, limit) {
+  if (lines.length <= limit || limit <= 0) {
+    return {
+      entries: lines.map((line, index) => ({ kind: "line", line, index })),
+      shown: lines.length,
+      hidden: 0
+    };
+  }
+  if (limit < 8) {
+    return {
+      entries: lines.slice(0, limit).map((line, index) => ({ kind: "line", line, index })),
+      shown: limit,
+      hidden: lines.length - limit
+    };
+  }
+  const head = Math.ceil(limit * 0.65);
+  const tail = Math.max(1, limit - head - 1);
+  const hidden = lines.length - head - tail;
+  return {
+    entries: [
+      ...lines.slice(0, head).map((line, index) => ({ kind: "line", line, index })),
+      { kind: "hidden", hidden },
+      ...lines.slice(-tail).map((line, offset) => ({
+        kind: "line",
+        line,
+        index: lines.length - tail + offset
+      }))
+    ],
+    shown: head + tail,
+    hidden
+  };
+}
+function collectPreviewTextLines(text) {
+  const lines = [];
+  forEachPreviewTextLine(text, (line) => lines.push(line));
+  return lines;
+}
+function forEachPreviewTextLine(text, callback) {
+  let index = 0;
+  let pendingEmpty = 0;
+  forEachRawTextLine(text, (line) => {
+    if (line === "") {
+      pendingEmpty++;
+      return;
+    }
+    while (pendingEmpty > 0) {
+      callback("", index++);
+      pendingEmpty--;
+    }
+    callback(line, index++);
+  });
+  if (index === 0 && pendingEmpty > 0 && text.length > 0) callback("", index);
+}
+function forEachRawTextLine(text, callback) {
+  let start = 0;
+  while (start <= text.length) {
+    const newline = text.indexOf("\n", start);
+    if (newline < 0) {
+      callback(text.slice(start));
+      break;
+    }
+    callback(text.slice(start, newline));
+    start = newline + 1;
+  }
+}
+
+// src/providers/write-diff-limits.ts
+var configuredMaxBytes = Number.parseInt(
+  process.env.CODE_PREVIEW_MAX_WRITE_DIFF_BYTES ?? "",
+  10
+);
+var MAX_WRITE_DIFF_BYTES = Number.isFinite(configuredMaxBytes) && configuredMaxBytes > 0 ? configuredMaxBytes : 2e5;
+var configuredMaxChangedLineCells = Number.parseInt(
+  process.env.CODE_PREVIEW_MAX_WRITE_DIFF_CHANGED_LINE_CELLS ?? "",
+  10
+);
+var MAX_WRITE_DIFF_CHANGED_LINE_CELLS = Number.isFinite(configuredMaxChangedLineCells) && configuredMaxChangedLineCells > 0 ? configuredMaxChangedLineCells : 1e6;
+var writeContentForPreview = (content) => Buffer.byteLength(content, "utf8") <= MAX_WRITE_DIFF_BYTES ? content : void 0;
+var shouldSkipWriteDiffBytes = (...texts) => {
+  let total = 0;
+  for (const text of texts) {
+    total += Buffer.byteLength(text, "utf8");
+    if (total > MAX_WRITE_DIFF_BYTES) return true;
+  }
+  return false;
+};
+var shouldSkipWriteDiffComplexity = (before, after) => {
+  const beforeLines = before.split("\n");
+  const afterLines = after.split("\n");
+  const sharedLimit = Math.min(beforeLines.length, afterLines.length);
+  let prefix = 0;
+  while (prefix < sharedLimit && beforeLines[prefix] === afterLines[prefix]) prefix++;
+  let suffix = 0;
+  const suffixLimit = sharedLimit - prefix;
+  while (suffix < suffixLimit && beforeLines[beforeLines.length - suffix - 1] === afterLines[afterLines.length - suffix - 1]) {
+    suffix++;
+  }
+  const changedBefore = beforeLines.length - prefix - suffix;
+  const changedAfter = afterLines.length - prefix - suffix;
+  return changedBefore * changedAfter > MAX_WRITE_DIFF_CHANGED_LINE_CELLS;
+};
+
+// src/ui/transcript-reader.ts
+import fs from "node:fs";
+
+// src/ui/transcript-parser.ts
+var MAX_TOOL_SUMMARY_CHARS = 500;
+var MAX_TRANSCRIPT_MESSAGE_CHARS = 4e4;
+var TRANSCRIPT_ENTRY_LIMIT = 80;
+var TranscriptAccumulator = class {
+  entries = [];
+  #tools = /* @__PURE__ */ new Map();
+  #anonymousTools = /* @__PURE__ */ new Map();
+  #activeTools = [];
+  #assistant;
+  #retry;
+  #compaction;
+  #userMessages = /* @__PURE__ */ new Map();
+  #userBoundaries = /* @__PURE__ */ new Map();
+  #sequence = 0;
+  append(events) {
+    for (const event of events) this.#append(event);
+  }
+  snapshot(olderAvailable = false, updatedAt, maxEntries = TRANSCRIPT_ENTRY_LIMIT) {
+    const entries = maxEntries > 0 && this.entries.length > maxEntries ? this.entries.slice(-maxEntries) : this.entries;
+    const omitted = entries.length < this.entries.length;
+    return {
+      entries: entries.map((entry) => ({ ...entry })),
+      truncated: olderAvailable || omitted,
+      hasMore: olderAvailable || omitted,
+      ...updatedAt !== void 0 ? { updatedAt } : {}
+    };
+  }
+  #nextId(event, prefix = "event") {
+    if (typeof event.toolCallId === "string") return event.toolCallId;
+    if (typeof event.uuid === "string") return event.uuid;
+    if (typeof event.id === "string") return event.id;
+    return `${prefix}-${this.#sequence++}`;
+  }
+  #finishAssistant(status) {
+    if (!this.#assistant) return;
+    this.#assistant.status = status;
+    this.#assistant = void 0;
+  }
+  #pushMessage(kind, id, text, status = "completed", label = kind === "assistant" ? "Agent" : "User", identity) {
+    const display = kind === "user" ? unwrapActorEnvelopeText(text) ?? text : text;
+    const safe = clip(display, MAX_TRANSCRIPT_MESSAGE_CHARS, kind !== "user");
+    if (!safe) return;
+    const entry = { id, kind, label, text: safe, status };
+    if (kind === "user" && identity) {
+      const existing = this.#userMessages.get(identity);
+      if (existing) {
+        existing.text = safe;
+        return;
+      }
+      this.#userMessages.set(identity, entry);
+    }
+    this.entries.push(entry);
+  }
+  #userIdentity(event, message) {
+    if (event.type === "message_start" || event.type === "message_end" || event.type === "message") {
+      const timestamp = message.timestamp;
+      if (typeof timestamp === "number" && Number.isFinite(timestamp)) {
+        const base = JSON.stringify([timestamp, contentText(message.content)]);
+        let boundary = this.#userBoundaries.get(base);
+        if (!boundary || event.type === "message_start" && boundary.ended) {
+          boundary = { serial: (boundary?.serial ?? -1) + 1, ended: false };
+          this.#userBoundaries.set(base, boundary);
+        }
+        if (event.type === "message_end") boundary.ended = true;
+        return `user:${base}:${boundary.serial}`;
+      }
+    }
+    return void 0;
+  }
+  #toolParent(id) {
+    if (!id.startsWith("fabric_")) return void 0;
+    for (let index = this.#activeTools.length - 1; index >= 0; index--) {
+      const candidate = this.#activeTools[index];
+      if (candidate?.toolName === "fabric_exec" && candidate.status === "running") return candidate;
+    }
+    return void 0;
+  }
+  #startTool(id, label, args) {
+    const existing = this.#tools.get(id);
+    const safeArgs = args === void 0 ? void 0 : redactRecord(args);
+    if (existing) {
+      if (safeArgs !== void 0) existing.args = safeArgs;
+      if (args !== void 0) existing.text = compactRedactedValue(safeArgs ?? redact(args));
+      return existing;
+    }
+    const parent = this.#toolParent(id);
+    const safeLabel = terminalSafe(label) || "tool";
+    const entry = {
+      id,
+      kind: "tool",
+      label: safeLabel,
+      toolName: safeLabel,
+      status: "running",
+      ...safeArgs !== void 0 ? { args: safeArgs } : {},
+      ...args !== void 0 ? { text: compactRedactedValue(safeArgs ?? redact(args)) } : {},
+      ...parent ? { parentId: parent.id, depth: (parent.depth ?? 0) + 1 } : {}
+    };
+    this.entries.push(entry);
+    this.#tools.set(id, entry);
+    this.#activeTools.push(entry);
+    return entry;
+  }
+  #finishTool(id, label, result, failed) {
+    const safeLabel = terminalSafe(label) || "tool";
+    const anonymous = this.#anonymousTools.get(safeLabel);
+    const entry = id ? this.#tools.get(id) : anonymous?.shift();
+    if (anonymous?.length === 0) this.#anonymousTools.delete(safeLabel);
+    const safeResult = result === void 0 ? void 0 : redact(result);
+    if (entry) {
+      entry.status = failed ? "failed" : "completed";
+      if (safeResult !== void 0) entry.result = safeResult;
+      if (failed && result !== void 0) {
+        const failure = compactRedactedValue(safeResult);
+        entry.text = clip(
+          `${entry.text ? `${entry.text} \xB7 ` : ""}error: ${failure}`,
+          MAX_TOOL_SUMMARY_CHARS
+        );
+      }
+      this.#tools.delete(entry.id);
+      const activeIndex = this.#activeTools.indexOf(entry);
+      if (activeIndex >= 0) this.#activeTools.splice(activeIndex, 1);
+      return;
+    }
+    this.entries.push({
+      id: id ?? `tool-${this.#sequence++}`,
+      kind: "tool",
+      label: safeLabel,
+      toolName: safeLabel,
+      status: failed ? "failed" : "completed",
+      ...safeResult !== void 0 ? { result: safeResult } : {},
+      ...failed && safeResult !== void 0 ? { text: compactRedactedValue(safeResult) } : {}
+    });
+  }
+  #appendSessionMessage(event, message) {
+    const id = this.#nextId(event, "message");
+    if (message.role === "user") {
+      this.#pushMessage("user", id, contentText(message.content), "completed", "User", this.#userIdentity(event, message));
+      return;
+    }
+    if (message.role === "assistant") {
+      const error = messageError(message);
+      const text = contentText(message.content);
+      if (text) this.#pushMessage("assistant", id, text, error ? "failed" : "completed");
+      if (error) {
+        this.entries.push({
+          id: `${id}-error`,
+          kind: "error",
+          label: "Agent error",
+          text: error,
+          status: "failed"
+        });
+      }
+      if (Array.isArray(message.content)) {
+        for (const value of message.content) {
+          const part = recordOf(value);
+          if (part?.type !== "toolCall" || typeof part.name !== "string") continue;
+          const toolId = typeof part.id === "string" ? part.id : `session-tool-${this.#sequence++}`;
+          this.#startTool(toolId, part.name, part.arguments);
+        }
+      }
+      return;
+    }
+    if (message.role === "toolResult") {
+      const toolId = typeof message.toolCallId === "string" ? message.toolCallId : void 0;
+      const label = typeof message.toolName === "string" ? message.toolName : "tool";
+      this.#finishTool(
+        toolId,
+        label,
+        { content: message.content, ...message.details !== void 0 ? { details: message.details } : {} },
+        message.isError === true
+      );
+    }
+  }
+  #append(event) {
+    if (typeof event.type !== "string") return;
+    const id = this.#nextId(event);
+    if (event.type === "message") {
+      const message = recordOf(event.message);
+      if (message) this.#appendSessionMessage(event, message);
+      return;
+    }
+    if (event.type === "model_changed") {
+      const provider = typeof event.provider === "string" ? event.provider : "";
+      const model = typeof event.modelId === "string" ? event.modelId : "";
+      this.entries.push({
+        id,
+        kind: "status",
+        label: "Model changed",
+        ...provider || model ? { text: [provider, model].filter(Boolean).join("/") } : {},
+        status: "completed"
+      });
+      return;
+    }
+    if (event.type === "thinking_level_changed") {
+      this.entries.push({
+        id,
+        kind: "status",
+        label: "Thinking changed",
+        ...typeof event.thinkingLevel === "string" ? { text: event.thinkingLevel } : {},
+        status: "completed"
+      });
+      return;
+    }
+    if (event.type === "compaction") {
+      this.entries.push({
+        id,
+        kind: "status",
+        label: "Compacted context",
+        ...typeof event.summary === "string" ? { text: terminalSafe(event.summary) } : {},
+        status: "completed"
+      });
+      return;
+    }
+    if (event.type === "stream_event") {
+      const stream = recordOf(event.event);
+      const delta = recordOf(stream?.delta);
+      if (stream?.type === "content_block_delta" && delta?.type === "text_delta") {
+        const text = typeof delta.text === "string" ? terminalSafe(delta.text, false) : "";
+        if (!text) return;
+        if (!this.#assistant) {
+          this.#assistant = {
+            id,
+            kind: "assistant",
+            label: "Claude",
+            text: clip(text, MAX_TRANSCRIPT_MESSAGE_CHARS, false),
+            status: "running"
+          };
+          this.entries.push(this.#assistant);
+        } else {
+          this.#assistant.text = clip(
+            `${this.#assistant.text ?? ""}${text}`,
+            MAX_TRANSCRIPT_MESSAGE_CHARS,
+            false
+          );
+        }
+      }
+      return;
+    }
+    if (event.type === "assistant") {
+      const message = recordOf(event.message);
+      if (!message || message.role !== "assistant") return;
+      if (Array.isArray(message.content)) {
+        for (const value of message.content) {
+          const part = recordOf(value);
+          if (part?.type !== "tool_use") continue;
+          const toolId = typeof part.id === "string" ? part.id : `claude-tool-${this.#sequence++}`;
+          const label = typeof part.name === "string" ? part.name : "tool";
+          this.#startTool(toolId, label, part.input);
+        }
+      }
+      const text = terminalSafe(contentText(message.content));
+      if (text) {
+        if (this.#assistant) {
+          this.#assistant.text = clip(text, MAX_TRANSCRIPT_MESSAGE_CHARS);
+          this.#finishAssistant("completed");
+        } else {
+          this.#pushMessage("assistant", id, text, "completed", "Claude");
+        }
+      }
+      if (typeof event.error === "string") {
+        this.entries.push({
+          id: `${id}-error`,
+          kind: "error",
+          label: "Claude error",
+          text: clip(event.error, MAX_TOOL_SUMMARY_CHARS),
+          status: "failed"
+        });
+      }
+      return;
+    }
+    if (event.type === "user") {
+      const message = recordOf(event.message);
+      if (!message || !Array.isArray(message.content)) return;
+      let hasToolResult = false;
+      for (const value of message.content) {
+        const part = recordOf(value);
+        if (part?.type !== "tool_result" || typeof part.tool_use_id !== "string") continue;
+        hasToolResult = true;
+        this.#finishTool(part.tool_use_id, "tool", part.content, part.is_error === true);
+      }
+      if (!hasToolResult) this.#pushMessage("user", id, contentText(message.content));
+      return;
+    }
+    if (event.type === "result") {
+      this.#finishAssistant(event.is_error === true ? "failed" : "completed");
+      if (event.is_error === true || event.subtype !== "success") {
+        const errors = Array.isArray(event.errors) ? event.errors.filter((value) => typeof value === "string").join(" \xB7 ") : "";
+        const text = errors || (typeof event.result === "string" ? event.result : "Claude run failed");
+        this.entries.push({
+          id,
+          kind: "error",
+          label: "Claude result",
+          text: clip(text, MAX_TOOL_SUMMARY_CHARS),
+          status: "failed"
+        });
+      }
+      return;
+    }
+    if (event.type === "system" && event.subtype === "api_retry") {
+      this.entries.push({
+        id,
+        kind: "status",
+        label: "Claude API retry",
+        status: "running",
+        ...typeof event.error === "string" ? { text: clip(event.error, MAX_TOOL_SUMMARY_CHARS) } : {}
+      });
+      return;
+    }
+    if (event.type === "message_start") this.#finishAssistant("completed");
+    if (event.type === "message_start" || event.type === "message_update") {
+      const message = recordOf(event.message);
+      if (!message) return;
+      if (message.role === "user") {
+        if (event.type === "message_start") {
+          this.#pushMessage("user", id, contentText(message.content), "completed", "User", this.#userIdentity(event, message));
+        }
+        return;
+      }
+      if (message.role !== "assistant") return;
+      const text = terminalSafe(contentText(message.content));
+      if (!text) return;
+      if (!this.#assistant) {
+        this.#assistant = {
+          id,
+          kind: "assistant",
+          label: "Agent",
+          text: clip(text, MAX_TRANSCRIPT_MESSAGE_CHARS),
+          status: "running"
+        };
+        this.entries.push(this.#assistant);
+      } else {
+        this.#assistant.text = clip(text, MAX_TRANSCRIPT_MESSAGE_CHARS);
+        if (!this.entries.includes(this.#assistant)) this.entries.push(this.#assistant);
+      }
+      return;
+    }
+    if (event.type === "message_end") {
+      const message = recordOf(event.message);
+      if (!message) return;
+      if (message.role === "user") {
+        this.#pushMessage("user", id, contentText(message.content), "completed", "User", this.#userIdentity(event, message));
+        return;
+      }
+      if (message.role !== "assistant") return;
+      const error = messageError(message);
+      if (error) {
+        this.#finishAssistant("failed");
+        this.entries.push({ id, kind: "error", label: "Agent error", text: error, status: "failed" });
+        return;
+      }
+      const text = terminalSafe(contentText(message.content));
+      if (!text) {
+        this.#finishAssistant("completed");
+        return;
+      }
+      if (!this.#assistant) this.#pushMessage("assistant", id, text);
+      else {
+        this.#assistant.text = clip(text, MAX_TRANSCRIPT_MESSAGE_CHARS);
+        this.#finishAssistant("completed");
+      }
+      return;
+    }
+    if (event.type === "response" && event.command === "prompt" && event.success === false) {
+      const text = typeof event.error === "string" ? event.error : "OMP rejected the prompt";
+      this.entries.push({
+        id,
+        kind: "error",
+        label: "Prompt rejected",
+        text: clip(text, MAX_TOOL_SUMMARY_CHARS),
+        status: "failed"
+      });
+      return;
+    }
+    if (event.type === "tool_execution_start") {
+      const label = typeof event.toolName === "string" ? event.toolName : "tool";
+      const entry = this.#startTool(id, label, event.args);
+      if (typeof event.toolCallId !== "string") {
+        const key = terminalSafe(label) || "tool";
+        this.#tools.delete(entry.id);
+        this.#anonymousTools.set(key, [...this.#anonymousTools.get(key) ?? [], entry]);
+      }
+      return;
+    }
+    if (event.type === "tool_execution_end") {
+      const label = typeof event.toolName === "string" ? event.toolName : "tool";
+      this.#finishTool(
+        typeof event.toolCallId === "string" ? event.toolCallId : void 0,
+        label,
+        event.result,
+        event.isError === true
+      );
+      return;
+    }
+    if (event.type === "auto_retry_start") {
+      const attempt = typeof event.attempt === "number" ? ` ${event.attempt}` : "";
+      this.#retry = {
+        id,
+        kind: "status",
+        label: `Retry${attempt}`,
+        status: "running",
+        ...typeof event.errorMessage === "string" ? { text: clip(event.errorMessage, MAX_TOOL_SUMMARY_CHARS) } : {}
+      };
+      this.entries.push(this.#retry);
+      return;
+    }
+    if (event.type === "auto_retry_end") {
+      const failed = event.success === false;
+      if (this.#retry) {
+        this.#retry.status = failed ? "failed" : "completed";
+        if (failed && typeof event.finalError === "string") {
+          this.#retry.text = clip(event.finalError, MAX_TOOL_SUMMARY_CHARS);
+        }
+        this.#retry = void 0;
+      }
+      return;
+    }
+    if (event.type === "auto_compaction_start") {
+      this.#compaction = {
+        id,
+        kind: "status",
+        label: "Compacting context",
+        status: "running"
+      };
+      this.entries.push(this.#compaction);
+      return;
+    }
+    if (event.type === "auto_compaction_end") {
+      if (this.#compaction) {
+        const failed = event.aborted === true || typeof event.errorMessage === "string";
+        this.#compaction.status = failed ? "failed" : "completed";
+        if (typeof event.errorMessage === "string") {
+          this.#compaction.text = clip(event.errorMessage, MAX_TOOL_SUMMARY_CHARS);
+        }
+        this.#compaction = void 0;
+      }
+      return;
+    }
+    if (event.type === "extension_error" || event.type === "worker_stderr") {
+      const text = typeof event.error === "string" ? event.error : typeof event.text === "string" ? event.text : "Extension error";
+      const warningLines = text.split(/\r?\n/).filter((line) => line.trim());
+      const warningCount = event.type === "worker_stderr" && warningLines.length > 0 && warningLines.every((line) => /^\s*Warning:/.test(line)) ? warningLines.length : 0;
+      this.entries.push({
+        id,
+        kind: "error",
+        label: event.type === "worker_stderr" ? "Worker stderr" : "Error",
+        text: clip(text, warningCount > 0 ? MAX_TRANSCRIPT_MESSAGE_CHARS : MAX_TOOL_SUMMARY_CHARS),
+        ...event.type === "worker_stderr" ? { warningCount } : {},
+        status: "failed"
+      });
+    }
+  }
+};
+var parseRaw = (raw) => {
+  try {
+    return recordOf(JSON.parse(raw));
+  } catch {
+    return void 0;
+  }
+};
+var parsedEvents = (lines) => lines.map((line) => recordOf(line.parsed) ?? parseRaw(line.raw)).filter((event) => event !== void 0);
+var normalizedToolStarts = (event) => {
+  if (event.type === "tool_execution_start" && typeof event.toolCallId === "string") {
+    return [{ id: event.toolCallId, event }];
+  }
+  const starts = [];
+  const appendContentStarts = (content, type) => {
+    if (!Array.isArray(content)) return;
+    for (const value of content) {
+      const part = recordOf(value);
+      if (part?.type !== type || typeof part.id !== "string") continue;
+      const name = typeof part.name === "string" ? part.name : "tool";
+      starts.push({
+        id: part.id,
+        event: {
+          type: "tool_execution_start",
+          toolCallId: part.id,
+          toolName: name,
+          args: type === "toolCall" ? part.arguments : part.input
+        }
+      });
+    }
+  };
+  if (event.type === "message") {
+    const message = recordOf(event.message);
+    if (message?.role === "assistant") appendContentStarts(message.content, "toolCall");
+  } else if (event.type === "assistant") {
+    const message = recordOf(event.message);
+    if (message?.role === "assistant") appendContentStarts(message.content, "tool_use");
+  }
+  return starts;
+};
+var toolLifecycleEndIds = (event) => {
+  if (event.type === "tool_execution_end" && typeof event.toolCallId === "string") {
+    return [event.toolCallId];
+  }
+  if (event.type === "message") {
+    const message2 = recordOf(event.message);
+    return message2?.role === "toolResult" && typeof message2.toolCallId === "string" ? [message2.toolCallId] : [];
+  }
+  if (event.type !== "user") return [];
+  const message = recordOf(event.message);
+  if (!Array.isArray(message?.content)) return [];
+  return message.content.flatMap((value) => {
+    const part = recordOf(value);
+    return part?.type === "tool_result" && typeof part.tool_use_id === "string" ? [part.tool_use_id] : [];
+  });
+};
+var missingToolStartIds = (events) => {
+  const active = /* @__PURE__ */ new Set();
+  const missing = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    for (const start of normalizedToolStarts(event)) active.add(start.id);
+    for (const id of toolLifecycleEndIds(event)) {
+      if (active.has(id)) active.delete(id);
+      else missing.add(id);
+    }
+  }
+  return missing;
+};
+
+// src/ui/transcript-reader.ts
+var PAGE_LINES = 40;
+var TOOL_LIFECYCLE_CONTEXT_LINES = PAGE_LINES * 4;
+var MAX_PAGE_BYTES = 512 * 1024;
+var MAX_CACHE_ENTRIES = 32;
+var FORWARD_READ_CHUNK_BYTES = 64 * 1024;
+var completeLogEnd = (descriptor, size, fallback = 0) => {
+  if (size <= 0) return 0;
+  const scanFloor = Math.max(0, size - MAX_PAGE_BYTES);
+  let scanEnd = size;
+  while (scanEnd > scanFloor) {
+    const scanStart = Math.max(scanFloor, scanEnd - FORWARD_READ_CHUNK_BYTES);
+    const chunk = Buffer.allocUnsafe(scanEnd - scanStart);
+    const bytesRead = fs.readSync(descriptor, chunk, 0, chunk.length, scanStart);
+    if (bytesRead <= 0) return 0;
+    for (let index = bytesRead - 1; index >= 0; index--) {
+      if (chunk[index] === 10) return scanStart + index + 1;
+    }
+    scanEnd = scanStart;
+  }
+  return Math.min(fallback, size);
+};
+var readForwardPage = (descriptor, start, end) => {
+  const lines = [];
+  const readLimit = Math.min(end, Math.max(0, start) + MAX_PAGE_BYTES);
+  let readOffset = Math.max(0, start);
+  let pending = Buffer.alloc(0);
+  let pendingOffset = readOffset;
+  let pageEnd = readOffset;
+  while (readOffset < readLimit && lines.length < PAGE_LINES) {
+    const chunkSize = Math.min(FORWARD_READ_CHUNK_BYTES, readLimit - readOffset);
+    const chunk = Buffer.allocUnsafe(chunkSize);
+    const bytesRead = fs.readSync(descriptor, chunk, 0, chunkSize, readOffset);
+    if (bytesRead <= 0) break;
+    const data = pending.length > 0 ? Buffer.concat([pending, chunk.subarray(0, bytesRead)]) : chunk.subarray(0, bytesRead);
+    const dataOffset = pending.length > 0 ? pendingOffset : readOffset;
+    let lineStart = 0;
+    for (let index = 0; index < data.length; index++) {
+      if (data[index] !== 10) continue;
+      const raw = data.subarray(lineStart, index).toString("utf8").replace(/\r$/, "");
+      pageEnd = dataOffset + index + 1;
+      if (raw) {
+        const offset = dataOffset + lineStart;
+        const parsed = parseRaw(raw);
+        lines.push({ offset, raw, ...parsed ? { parsed } : {} });
+        if (lines.length >= PAGE_LINES) return { lines, end: pageEnd };
+      }
+      lineStart = index + 1;
+    }
+    pending = Buffer.from(data.subarray(lineStart));
+    pendingOffset = dataOffset + lineStart;
+    readOffset += bytesRead;
+  }
+  return { lines, end: readOffset >= end ? end : pageEnd };
+};
+var AgentTranscriptReader = class {
+  #cache = /* @__PURE__ */ new Map();
+  read(source, followLatest = true) {
+    const filePath = source.logFile;
+    if (!filePath) {
+      return { entries: [], truncated: false, hasMore: false, hasNewer: false };
+    }
+    const cached = this.#cache.get(filePath);
+    let descriptor;
+    try {
+      const noFollow = typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0;
+      descriptor = fs.openSync(filePath, fs.constants.O_RDONLY | noFollow);
+      const stat = fs.fstatSync(descriptor);
+      if (!stat.isFile()) {
+        return cached?.transcript ?? {
+          entries: [],
+          truncated: false,
+          hasMore: false,
+          hasNewer: false
+        };
+      }
+      const sameFile = cached?.device === stat.dev && cached.inode === stat.ino;
+      const sameSizeRewrite = sameFile && cached.offset === stat.size && cached.modifiedAt !== stat.mtimeMs;
+      let state;
+      if (!cached || !sameFile || stat.size < cached.offset || sameSizeRewrite) {
+        state = this.#latestState(descriptor, stat);
+      } else if (stat.size !== cached.offset || stat.mtimeMs !== cached.modifiedAt) {
+        const wasAtTail = cached.pageEnd >= cached.completeEnd;
+        const completeEnd = completeLogEnd(descriptor, stat.size, cached.completeEnd);
+        if (cached.pageEnd > completeEnd || followLatest && wasAtTail && completeEnd > cached.completeEnd) {
+          state = this.#latestState(descriptor, stat, completeEnd);
+        } else {
+          state = {
+            ...cached,
+            modifiedAt: stat.mtimeMs,
+            offset: stat.size,
+            completeEnd,
+            transcript: {
+              ...cached.transcript,
+              hasNewer: cached.pageEnd < completeEnd,
+              updatedAt: stat.mtimeMs
+            }
+          };
+        }
+      } else {
+        state = cached;
+      }
+      this.#remember(filePath, state);
+      return state.transcript;
+    } catch {
+      return cached?.transcript ?? {
+        entries: [],
+        truncated: false,
+        hasMore: false,
+        hasNewer: false
+      };
+    } finally {
+      if (descriptor !== void 0) {
+        try {
+          fs.closeSync(descriptor);
+        } catch {
+        }
+      }
+    }
+  }
+  loadOlder(source) {
+    const filePath = source.logFile;
+    if (!filePath) return false;
+    this.read(source, false);
+    const cached = this.#cache.get(filePath);
+    if (!cached?.hasMore || cached.pageStart <= 0) return false;
+    let descriptor;
+    try {
+      const noFollow = typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0;
+      descriptor = fs.openSync(filePath, fs.constants.O_RDONLY | noFollow);
+      const stat = fs.fstatSync(descriptor);
+      if (!stat.isFile() || stat.dev !== cached.device || stat.ino !== cached.inode) return false;
+      const completeEnd = completeLogEnd(descriptor, stat.size, cached.completeEnd);
+      const pageEnd = Math.min(cached.pageStart, completeEnd);
+      const page = readJsonlPageFromDescriptor(
+        descriptor,
+        PAGE_LINES,
+        pageEnd,
+        stat.size,
+        MAX_PAGE_BYTES
+      );
+      const pageStart = page.lines[0]?.offset;
+      if (pageStart === void 0) return false;
+      const state = this.#stateForPage(
+        descriptor,
+        stat,
+        completeEnd,
+        page.lines,
+        pageStart,
+        pageEnd,
+        page.hasMore
+      );
+      this.#remember(filePath, state);
+      return true;
+    } catch {
+      return false;
+    } finally {
+      if (descriptor !== void 0) {
+        try {
+          fs.closeSync(descriptor);
+        } catch {
+        }
+      }
+    }
+  }
+  loadNewer(source) {
+    const filePath = source.logFile;
+    if (!filePath) return false;
+    this.read(source, false);
+    const cached = this.#cache.get(filePath);
+    if (!cached || cached.pageEnd >= cached.completeEnd) return false;
+    let descriptor;
+    try {
+      const noFollow = typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0;
+      descriptor = fs.openSync(filePath, fs.constants.O_RDONLY | noFollow);
+      const stat = fs.fstatSync(descriptor);
+      if (!stat.isFile() || stat.dev !== cached.device || stat.ino !== cached.inode) return false;
+      const completeEnd = completeLogEnd(descriptor, stat.size, cached.completeEnd);
+      const page = readForwardPage(descriptor, cached.pageEnd, completeEnd);
+      if (page.lines.length === 0 || page.end <= cached.pageEnd) return false;
+      const state = this.#stateForPage(
+        descriptor,
+        stat,
+        completeEnd,
+        page.lines,
+        cached.pageEnd,
+        page.end,
+        cached.pageEnd > 0
+      );
+      this.#remember(filePath, state);
+      return true;
+    } catch {
+      return false;
+    } finally {
+      if (descriptor !== void 0) {
+        try {
+          fs.closeSync(descriptor);
+        } catch {
+        }
+      }
+    }
+  }
+  loadLatest(source) {
+    const filePath = source.logFile;
+    if (!filePath) return false;
+    this.read(source, false);
+    const cached = this.#cache.get(filePath);
+    let descriptor;
+    try {
+      const noFollow = typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0;
+      descriptor = fs.openSync(filePath, fs.constants.O_RDONLY | noFollow);
+      const stat = fs.fstatSync(descriptor);
+      if (!stat.isFile()) return false;
+      if (cached && (stat.dev !== cached.device || stat.ino !== cached.inode)) return false;
+      const completeEnd = completeLogEnd(descriptor, stat.size, cached?.completeEnd ?? 0);
+      const state = this.#latestState(descriptor, stat, completeEnd);
+      this.#remember(filePath, state);
+      return true;
+    } catch {
+      return false;
+    } finally {
+      if (descriptor !== void 0) {
+        try {
+          fs.closeSync(descriptor);
+        } catch {
+        }
+      }
+    }
+  }
+  clear() {
+    this.#cache.clear();
+  }
+  #latestState(descriptor, stat, knownCompleteEnd) {
+    const completeEnd = knownCompleteEnd ?? completeLogEnd(descriptor, stat.size);
+    const page = readJsonlPageFromDescriptor(
+      descriptor,
+      PAGE_LINES,
+      completeEnd,
+      stat.size,
+      MAX_PAGE_BYTES
+    );
+    return this.#stateForPage(
+      descriptor,
+      stat,
+      completeEnd,
+      page.lines,
+      page.lines[0]?.offset ?? completeEnd,
+      completeEnd,
+      page.hasMore
+    );
+  }
+  #stateForPage(descriptor, stat, completeEnd, lines, pageStart, pageEnd, hasMore) {
+    const events = parsedEvents(lines);
+    const missingStarts = missingToolStartIds(events);
+    const lifecycleContext = [];
+    if (missingStarts.size > 0 && pageStart > 0) {
+      const contextPage = readJsonlPageFromDescriptor(
+        descriptor,
+        TOOL_LIFECYCLE_CONTEXT_LINES,
+        pageStart,
+        stat.size,
+        MAX_PAGE_BYTES
+      );
+      const contextEvents = parsedEvents(contextPage.lines);
+      for (let index = contextEvents.length - 1; index >= 0 && missingStarts.size > 0; index--) {
+        const starts = normalizedToolStarts(contextEvents[index]);
+        for (let startIndex = starts.length - 1; startIndex >= 0; startIndex--) {
+          const start = starts[startIndex];
+          if (!missingStarts.delete(start.id)) continue;
+          lifecycleContext.unshift(start.event);
+        }
+      }
+    }
+    const accumulator = new TranscriptAccumulator();
+    accumulator.append([...lifecycleContext, ...events]);
+    const transcript = {
+      ...accumulator.snapshot(hasMore, stat.mtimeMs, Number.MAX_SAFE_INTEGER),
+      hasNewer: pageEnd < completeEnd
+    };
+    return {
+      device: stat.dev,
+      inode: stat.ino,
+      modifiedAt: stat.mtimeMs,
+      offset: stat.size,
+      completeEnd,
+      pageStart,
+      pageEnd,
+      hasMore: transcript.hasMore ?? false,
+      transcript
+    };
+  }
+  #remember(filePath, state) {
+    this.#cache.delete(filePath);
+    this.#cache.set(filePath, state);
+    while (this.#cache.size > MAX_CACHE_ENTRIES) {
+      const oldest = this.#cache.keys().next().value;
+      if (!oldest) break;
+      this.#cache.delete(oldest);
+    }
+  }
+};
+
+// src/ui/transcript.ts
+var PREVIEW_TREE_GUARD_MAX_DEPTH = 8;
+var isFabricAgentToolPreviewNode = (value, depth) => {
+  const record = recordOf(value);
+  if (!record || typeof record.id !== "string" || typeof record.name !== "string" || record.text !== void 0 && typeof record.text !== "string" || record.currentTool !== void 0 && typeof record.currentTool !== "string" || !Array.isArray(record.tools)) {
+    return false;
+  }
+  if (record.agents === void 0) return true;
+  if (depth >= PREVIEW_TREE_GUARD_MAX_DEPTH || !Array.isArray(record.agents)) return false;
+  return record.agents.every((child) => isFabricAgentToolPreviewNode(child, depth + 1));
+};
+var isFabricAgentToolPreview = (value) => recordOf(value)?.kind === "fabric-agent-tools" && isFabricAgentToolPreviewNode(value, 0);
+var recentTranscriptTools = (transcript, limit = 2) => {
+  const tools = transcript.entries.filter((entry) => entry.kind === "tool");
+  const boundedLimit = Math.max(1, limit);
+  const running = tools.filter((entry) => entry.status === "running");
+  const completed = tools.filter((entry) => entry.status !== "running");
+  const completedSlots = Math.max(0, boundedLimit - Math.min(running.length, boundedLimit));
+  const retained = /* @__PURE__ */ new Set([
+    ...running.slice(-boundedLimit),
+    ...completed.slice(-completedSlots)
+  ]);
+  return tools.filter((entry) => retained.has(entry)).slice(-boundedLimit).map((entry) => ({ ...entry }));
+};
+
+export {
+  headlineArg,
+  countContentLines,
+  selectPreviewTextLines,
+  MAX_WRITE_DIFF_BYTES,
+  writeContentForPreview,
+  shouldSkipWriteDiffBytes,
+  shouldSkipWriteDiffComplexity,
+  AgentTranscriptReader,
+  isFabricAgentToolPreview,
+  recentTranscriptTools
+};
+//# sourceMappingURL=chunk-HDJBUXDX.js.map