@iowarp/clio-coder 0.4.3 → 0.4.4

package/dist/chunk-XXYSBZIQ.js

@@ -0,0 +1,283 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  WORKER_OUTPUT_MAX_BYTES,
+  durableAssistantTextFromEvent
+} from "./chunk-I2DWJ4GM.js";
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/observability/worker-progress.ts
+init_esm_shims();
+var WORKER_LIVE_TAIL_LINES = 40;
+var WORKER_LIVE_TAIL_MAX_BYTES = 4096;
+var WORKER_TOOL_NAME_LIMIT = 8;
+var WORKER_ACTION_TRAIL_LIMIT = 4;
+var WORKER_PROGRESS_WINDOW_MS = 250;
+var WORKER_PROGRESS_WINDOW_BYTES = 16384;
+var TAIL_TRUNCATION_MARKER = "";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function workerTextDelta(event) {
+  if (!isRecord(event)) return "";
+  if (event.type === "message_update") {
+    const assistantEvent = isRecord(event.assistantMessageEvent) ? event.assistantMessageEvent : null;
+    if (assistantEvent?.type !== "text_delta") return "";
+    return typeof assistantEvent.delta === "string" ? assistantEvent.delta : "";
+  }
+  if (event.type !== "text_delta") return "";
+  if (typeof event.delta === "string") return event.delta;
+  return typeof event.text === "string" ? event.text : "";
+}
+function isThinkingEvent(event) {
+  if (event.type === "thinking_delta") return true;
+  if (event.type !== "message_update") return false;
+  const assistantEvent = isRecord(event.assistantMessageEvent) ? event.assistantMessageEvent : null;
+  return assistantEvent?.type === "thinking_delta";
+}
+function toolEventAction(event) {
+  if (event.type !== "clio_coder_tool_start" && event.type !== "clio_coder_tool_finish") return null;
+  const payload = isRecord(event.payload) ? event.payload : null;
+  const tool = nonEmptyString(payload?.tool);
+  if (tool === void 0) return null;
+  const toolCallId = nonEmptyString(payload?.toolCallId);
+  const raw = isRecord(payload?.action) ? payload.action : void 0;
+  const verb = nonEmptyString(raw?.verb);
+  if (verb === void 0) return { tool, ...toolCallId !== void 0 ? { toolCallId } : {} };
+  const object = nonEmptyString(raw?.object);
+  return {
+    tool,
+    ...toolCallId !== void 0 ? { toolCallId } : {},
+    descriptor: {
+      verb,
+      ...object !== void 0 ? { object } : {},
+      ...raw?.truncated === true ? { truncated: true } : {}
+    }
+  };
+}
+function lineCount(text) {
+  if (text.length === 0) return 0;
+  let lines = 1;
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] === "\n") lines += 1;
+  }
+  return lines;
+}
+function keepTailBytes(text, maxBytes) {
+  const buffer = Buffer.from(text, "utf8");
+  if (buffer.byteLength <= maxBytes) return text;
+  let cut = buffer.byteLength - maxBytes;
+  while (cut < buffer.byteLength) {
+    const byte = buffer[cut];
+    if (byte === void 0 || (byte & 192) !== 128) break;
+    cut += 1;
+  }
+  return buffer.subarray(cut).toString("utf8");
+}
+function boundLiveTail(text) {
+  const lines = text.split("\n");
+  let droppedLines = 0;
+  if (lines.length > WORKER_LIVE_TAIL_LINES) {
+    droppedLines = lines.length - WORKER_LIVE_TAIL_LINES;
+    lines.splice(0, droppedLines);
+  }
+  while (lines.length > 1 && Buffer.byteLength(lines.join("\n"), "utf8") > WORKER_LIVE_TAIL_MAX_BYTES) {
+    lines.shift();
+    droppedLines += 1;
+  }
+  const joined = lines.join("\n");
+  const bytes = Buffer.byteLength(joined, "utf8");
+  if (bytes <= WORKER_LIVE_TAIL_MAX_BYTES) return { text: joined, droppedLines, droppedBytes: 0 };
+  const kept = keepTailBytes(joined, WORKER_LIVE_TAIL_MAX_BYTES);
+  return { text: kept, droppedLines, droppedBytes: bytes - Buffer.byteLength(kept, "utf8") };
+}
+function boundSettledText(text) {
+  const bounded = truncateUtf8(text, WORKER_OUTPUT_MAX_BYTES, TAIL_TRUNCATION_MARKER);
+  if (bounded === text) return { text, dropped: 0 };
+  return { text: bounded, dropped: Math.max(0, lineCount(text) - lineCount(bounded)) };
+}
+var EMPTY_SNAPSHOT = {
+  revision: 0,
+  phase: "starting",
+  tailText: "",
+  droppedLines: 0,
+  droppedBytes: 0,
+  currentAction: null,
+  recentActions: [],
+  toolNames: [],
+  settled: false
+};
+function createWorkerProgressFold() {
+  let revision = 0;
+  let phase = "starting";
+  let tailText = "";
+  let droppedLines = 0;
+  let droppedBytes = 0;
+  let currentAction = null;
+  const recentActions = [];
+  const toolNames = [];
+  let settled = false;
+  let durable = "";
+  let betweenAssistantMessages = false;
+  const pendingActions = [];
+  const pendingActionsById = /* @__PURE__ */ new Map();
+  let windowStartMs = 0;
+  let windowBytes = 0;
+  let cached = EMPTY_SNAPSHOT;
+  const touch = () => {
+    revision += 1;
+    cached = null;
+    return true;
+  };
+  const setPhase = (next) => {
+    if (phase === next) return false;
+    phase = next;
+    return touch();
+  };
+  const admitDelta = (delta, nowMs) => {
+    if (nowMs - windowStartMs >= WORKER_PROGRESS_WINDOW_MS) {
+      windowStartMs = nowMs;
+      windowBytes = 0;
+    }
+    const bytes = Buffer.byteLength(delta, "utf8");
+    if (windowBytes + bytes <= WORKER_PROGRESS_WINDOW_BYTES) {
+      windowBytes += bytes;
+      return delta;
+    }
+    windowBytes = WORKER_PROGRESS_WINDOW_BYTES;
+    droppedBytes += bytes;
+    return "";
+  };
+  const appendTail = (text) => {
+    if (text.length === 0) return false;
+    const bounded = boundLiveTail(tailText + text);
+    tailText = bounded.text;
+    droppedLines += bounded.droppedLines;
+    droppedBytes += bounded.droppedBytes;
+    return touch();
+  };
+  const noteToolName = (tool) => {
+    if (toolNames.includes(tool) || toolNames.length >= WORKER_TOOL_NAME_LIMIT) return false;
+    toolNames.push(tool);
+    return touch();
+  };
+  const removePendingAction = (action) => {
+    const index = pendingActions.lastIndexOf(action);
+    if (index >= 0) pendingActions.splice(index, 1);
+    if (action.toolCallId !== void 0 && pendingActionsById.get(action.toolCallId) === action) {
+      pendingActionsById.delete(action.toolCallId);
+    }
+  };
+  const lastPendingActionForTool = (tool) => {
+    for (let index = pendingActions.length - 1; index >= 0; index -= 1) {
+      const candidate = pendingActions[index];
+      if (candidate?.tool === tool) return candidate;
+    }
+    return void 0;
+  };
+  return {
+    observe(event, nowMs = Date.now()) {
+      if (!isRecord(event) || settled) return false;
+      let changed = false;
+      const delta = workerTextDelta(event);
+      if (delta.length > 0) {
+        const separator = betweenAssistantMessages && tailText.length > 0 && !tailText.endsWith("\n") ? "\n\n" : "";
+        betweenAssistantMessages = false;
+        changed = appendTail(admitDelta(`${separator}${delta}`, nowMs)) || changed;
+        changed = setPhase("writing") || changed;
+      } else if (isThinkingEvent(event)) {
+        changed = setPhase("thinking") || changed;
+      }
+      const durableText = durableAssistantTextFromEvent(event);
+      if (durableText.trim().length > 0) {
+        durable = durableText;
+        if (delta.length === 0 && tailText.trim().length === 0) {
+          changed = appendTail(durableText) || changed;
+        }
+        betweenAssistantMessages = true;
+      }
+      const action = toolEventAction(event);
+      if (action !== null && event.type === "clio_coder_tool_start") {
+        if (action.toolCallId !== void 0) {
+          const duplicate = pendingActionsById.get(action.toolCallId);
+          if (duplicate !== void 0) removePendingAction(duplicate);
+          pendingActionsById.set(action.toolCallId, action);
+        }
+        pendingActions.push(action);
+        currentAction = action;
+        noteToolName(action.tool);
+        touch();
+        setPhase("tool");
+        changed = true;
+      } else if (action !== null && event.type === "clio_coder_tool_finish") {
+        const finished = (action.toolCallId !== void 0 ? pendingActionsById.get(action.toolCallId) : void 0) ?? lastPendingActionForTool(action.tool) ?? action;
+        removePendingAction(finished);
+        currentAction = pendingActions[pendingActions.length - 1] ?? null;
+        recentActions.unshift(finished);
+        if (recentActions.length > WORKER_ACTION_TRAIL_LIMIT) recentActions.length = WORKER_ACTION_TRAIL_LIMIT;
+        noteToolName(finished.tool);
+        touch();
+        setPhase(currentAction === null ? "waiting" : "tool");
+        changed = true;
+      }
+      if (event.type === "agent_start") changed = setPhase("starting") || changed;
+      return changed;
+    },
+    settle(text) {
+      const sealed = nonEmptyString(text) ?? nonEmptyString(durable);
+      if (sealed !== void 0) {
+        const bounded = boundSettledText(sealed);
+        tailText = bounded.text;
+        droppedLines = bounded.dropped;
+      }
+      currentAction = null;
+      pendingActions.length = 0;
+      pendingActionsById.clear();
+      settled = true;
+      phase = "settled";
+      touch();
+      return true;
+    },
+    restart() {
+      currentAction = null;
+      pendingActions.length = 0;
+      pendingActionsById.clear();
+      durable = "";
+      betweenAssistantMessages = false;
+      settled = false;
+      phase = "starting";
+      touch();
+    },
+    snapshot() {
+      if (cached !== null) return cached;
+      cached = {
+        revision,
+        phase,
+        tailText,
+        droppedLines,
+        droppedBytes,
+        currentAction: currentAction === null ? null : { ...currentAction },
+        recentActions: recentActions.map((entry) => ({ ...entry })),
+        toolNames: [...toolNames],
+        settled
+      };
+      return cached;
+    },
+    durableText() {
+      return durable;
+    }
+  };
+}
+
+export {
+  boundSettledText,
+  createWorkerProgressFold
+};
+//# sourceMappingURL=chunk-XXYSBZIQ.js.map