@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-IGLVVNEG.js

@@ -1,402 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  resultContractOutputBytes
-} from "./chunk-OQM5IVJY.js";
-import {
-  decisionRef
-} from "./chunk-KAFMW7WM.js";
-import {
-  truncateUtf8
-} from "./chunk-MYI32N4R.js";
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/domains/dispatch/event-pump.ts
-init_esm_shims();
-var EVENT_TEE_LIMIT = 1024;
-function startDispatchEventPump(source, fold, options = {}) {
-  const limit = options.limit ?? EVENT_TEE_LIMIT;
-  const pending = [...options.prelude ?? []];
-  const waiters = [];
-  let finished = false;
-  let abandoned = false;
-  let dropped = 0;
-  const push = (value) => {
-    if (abandoned) return;
-    const waiter = waiters.shift();
-    if (waiter) {
-      waiter({ value, done: false });
-      return;
-    }
-    pending.push(value);
-    while (pending.length > limit) {
-      pending.shift();
-      dropped += 1;
-    }
-  };
-  const end = () => {
-    finished = true;
-    while (waiters.length > 0) {
-      waiters.shift()?.({ value: void 0, done: true });
-    }
-  };
-  const notify = (event) => {
-    try {
-      options.onEvent?.(event);
-    } catch (error) {
-      options.onError?.(error);
-    }
-  };
-  const done = (async () => {
-    try {
-      for (const event of options.prelude ?? []) notify(event);
-      for await (const event of source) {
-        try {
-          fold(event);
-        } catch (error) {
-          options.onError?.(error);
-        }
-        notify(event);
-        push(event);
-      }
-    } catch (error) {
-      options.onError?.(error);
-    } finally {
-      end();
-    }
-  })();
-  const events = {
-    next() {
-      if (pending.length > 0) {
-        return Promise.resolve({ value: pending.shift(), done: false });
-      }
-      if (finished || abandoned) return Promise.resolve({ value: void 0, done: true });
-      return new Promise((resolve) => {
-        waiters.push(resolve);
-      });
-    },
-    return() {
-      abandoned = true;
-      pending.length = 0;
-      while (waiters.length > 0) {
-        waiters.shift()?.({ value: void 0, done: true });
-      }
-      return Promise.resolve({ value: void 0, done: true });
-    },
-    [Symbol.asyncIterator]() {
-      return this;
-    }
-  };
-  return { events, done, droppedEvents: () => dropped };
-}
-var WORKER_OUTPUT_MAX_BYTES = 8192;
-var WORKER_OUTPUT_TRUNCATION_MARKER = "\n[worker output truncated]";
-function workerOutputCaptureBytes(contract) {
-  return Math.max(WORKER_OUTPUT_MAX_BYTES, resultContractOutputBytes(contract) ?? 0);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function assistantTextFromContent(content) {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  return content.map((block) => {
-    if (typeof block === "string") return block;
-    if (!isRecord(block)) return "";
-    return typeof block.text === "string" ? block.text : "";
-  }).join("");
-}
-function isDurableAssistantMessage(message) {
-  const stopReason = message.stopReason;
-  if (stopReason === "toolUse" || stopReason === "error" || stopReason === "aborted" || stopReason === "cancelled") {
-    return false;
-  }
-  if (!Array.isArray(message.content)) return true;
-  return !message.content.some((block) => isRecord(block) && block.type === "toolCall");
-}
-function durableAssistantTextFromEvent(event) {
-  if (!isRecord(event) || event.type !== "message_end" || !isRecord(event.message)) return "";
-  if (event.message.role !== "assistant" || !isDurableAssistantMessage(event.message)) return "";
-  return assistantTextFromContent(event.message.content);
-}
-function boundedOutput(state, text, maxBytes) {
-  const bytes = Buffer.byteLength(text, "utf8");
-  const bounded = truncateUtf8(text, maxBytes, WORKER_OUTPUT_TRUNCATION_MARKER);
-  return { state, text: bounded, bytes, truncated: bounded !== text };
-}
-function createWorkerOutputCapture(options = {}) {
-  const maxBytes = Math.max(WORKER_OUTPUT_MAX_BYTES, Math.floor(options.maxBytes ?? WORKER_OUTPUT_MAX_BYTES));
-  let finalText = null;
-  let partialText = "";
-  let partialBytes = 0;
-  let partialStored = 0;
-  return {
-    observe(event) {
-      if (!isRecord(event)) return;
-      if (event.type === "message_end") {
-        const message = isRecord(event.message) ? event.message : null;
-        partialText = "";
-        partialBytes = 0;
-        partialStored = 0;
-        if (message === null || message.role !== "assistant") return;
-        if (!isDurableAssistantMessage(message)) return;
-        const text = assistantTextFromContent(message.content).trim();
-        if (text.length > 0) finalText = text;
-        return;
-      }
-      if (event.type !== "message_update") return;
-      const assistantEvent = isRecord(event.assistantMessageEvent) ? event.assistantMessageEvent : null;
-      if (assistantEvent === null || assistantEvent.type !== "text_delta") return;
-      const delta = assistantEvent.delta;
-      if (typeof delta !== "string" || delta.length === 0) return;
-      partialBytes += Buffer.byteLength(delta, "utf8");
-      if (partialStored < maxBytes) {
-        partialText += delta;
-        partialStored += Buffer.byteLength(delta, "utf8");
-      }
-    },
-    snapshot() {
-      if (partialBytes > 0 && partialText.trim().length > 0) {
-        const bounded = truncateUtf8(partialText.trim(), maxBytes, WORKER_OUTPUT_TRUNCATION_MARKER);
-        return {
-          state: "partial",
-          text: bounded,
-          bytes: partialBytes,
-          truncated: bounded !== partialText.trim() || partialBytes > partialStored
-        };
-      }
-      if (finalText !== null) return boundedOutput("final", finalText, maxBytes);
-      return void 0;
-    }
-  };
-}
-
-// src/domains/dispatch/admission-error.ts
-init_esm_shims();
-var AdmissionCanceledError = class extends Error {
-  code = "admission_canceled";
-  constructor(message = "dispatch: admission canceled before a capacity slot opened") {
-    super(message);
-    this.name = "AdmissionCanceledError";
-  }
-};
-
-// src/domains/session/decision-board.ts
-init_esm_shims();
-import { randomUUID } from "node:crypto";
-function answeredAtForDecision(policy, sourceQuestion) {
-  for (let index = policy.rounds.length - 1; index >= 0; index -= 1) {
-    const round = policy.rounds[index];
-    if (!round?.answeredAt) continue;
-    if (round.answers.some((answer) => answer.question === sourceQuestion)) return round.answeredAt;
-    if (round.questions.some((question) => question.question === sourceQuestion)) return round.answeredAt;
-  }
-  return void 0;
-}
-function finalizedInterviewEntryFields(policy) {
-  if (policy.rounds.length === 0 && policy.decisions.length === 0) return null;
-  if (!policy.turnId) throw new Error(`decision board: interview ${policy.id} has no originating user turn`);
-  if (policy.status !== "complete" && policy.status !== "cancelled") {
-    throw new Error(`decision board: interview ${policy.id} finalized with status ${policy.status}`);
-  }
-  const endedAt = policy.endedAt ?? policy.updatedAt;
-  const decisionsByKey = /* @__PURE__ */ new Map();
-  for (const decision of policy.decisions) {
-    const decidedAt = decision.source_question ? answeredAtForDecision(policy, decision.source_question) ?? endedAt : endedAt;
-    decisionsByKey.set(decision.key, {
-      key: decision.key,
-      value: decision.value,
-      ...decision.label ? { label: decision.label } : {},
-      ...decision.source_question ? { source_question: decision.source_question } : {},
-      status: "active",
-      decidedAt
-    });
-  }
-  return {
-    kind: "decisionLedger",
-    parentTurnId: policy.turnId,
-    interviewId: policy.id,
-    interviewStatus: policy.status,
-    startedAt: policy.startedAt,
-    endedAt,
-    roundCount: policy.rounds.length,
-    ...policy.summary ? { summary: policy.summary } : {},
-    ...policy.transcriptPath ? { transcriptPath: policy.transcriptPath } : {},
-    exposure: policy.exposure ?? "local",
-    decisions: [...decisionsByKey.values()]
-  };
-}
-var DECISION_REFS_CAP = 32;
-function activeDecisionRefs(board) {
-  const refs = /* @__PURE__ */ new Set();
-  for (const entry of board) {
-    for (const decision of entry.decisions) {
-      if (decision.status === "active") refs.add(decisionRef(entry.interviewId, decision.key));
-    }
-  }
-  return [...refs].sort().slice(0, DECISION_REFS_CAP);
-}
-function isDecisionLedgerEntry(value) {
-  return !!value && typeof value === "object" && value.kind === "decisionLedger";
-}
-function foldDecisionBoard(entries) {
-  const lastByInterview = /* @__PURE__ */ new Map();
-  for (let index = 0; index < entries.length; index += 1) {
-    const raw = entries[index];
-    if (!isDecisionLedgerEntry(raw)) continue;
-    lastByInterview.set(raw.interviewId, { entry: raw, index });
-  }
-  return [...lastByInterview.values()].sort((left, right) => {
-    const byEndedAt = right.entry.endedAt.localeCompare(left.entry.endedAt);
-    return byEndedAt !== 0 ? byEndedAt : right.index - left.index;
-  }).map(({ entry }) => entry);
-}
-function activeLeafFromEntries(entries) {
-  for (let index = entries.length - 1; index >= 0; index -= 1) {
-    const entry = entries[index];
-    if (entry && typeof entry === "object" && entry.kind === "message") {
-      const turnId = entry.turnId;
-      if (typeof turnId === "string" && turnId.length > 0) return turnId;
-    }
-  }
-  return null;
-}
-function createDecisionBoardStore(deps = {}) {
-  let cachedSessionId;
-  let dirty = true;
-  let interviews = [];
-  const syncToSession = () => {
-    const sessionId = deps.getSessionId?.() ?? null;
-    if (!dirty && sessionId === cachedSessionId) return;
-    const entries = deps.readEntries?.() ?? [];
-    interviews = foldDecisionBoard(entries);
-    cachedSessionId = sessionId;
-    dirty = false;
-  };
-  const append = (entry) => {
-    if (!deps.appendEntry) throw new Error("decision board: no session ledger is available");
-    deps.appendEntry(entry);
-    dirty = true;
-  };
-  const revise = (interviewId, key, revisionSource, correction) => {
-    syncToSession();
-    const interview = interviews.find((candidate) => candidate.interviewId === interviewId);
-    if (!interview) throw new Error(`decision board: interview ${interviewId} was not found on the active branch`);
-    const selected = interview.decisions.find((decision) => decision.key === key);
-    if (!selected) throw new Error(`decision board: decision ${key} was not found in interview ${interviewId}`);
-    const revisedAt = (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
-    const normalizedCorrection = correction?.trim();
-    const entries = deps.readEntries?.() ?? [];
-    const parentTurnId = deps.getActiveLeafTurnId?.() ?? activeLeafFromEntries(entries);
-    if (!parentTurnId) throw new Error("decision board: no active branch leaf is available for the revision");
-    const revision = {
-      kind: "decisionLedger",
-      parentTurnId,
-      ...interview.origin !== void 0 ? { origin: interview.origin } : {},
-      interviewId: interview.interviewId,
-      interviewStatus: interview.interviewStatus,
-      startedAt: interview.startedAt,
-      endedAt: interview.endedAt,
-      roundCount: interview.roundCount,
-      ...interview.summary ? { summary: interview.summary } : {},
-      ...interview.transcriptPath ? { transcriptPath: interview.transcriptPath } : {},
-      ...interview.exposure ? { exposure: interview.exposure } : {},
-      decisions: interview.decisions.map((decision) => {
-        if (decision.key !== selected.key) return { ...decision };
-        const next = { ...decision, status: "superseded", revisedAt, revisionSource };
-        if (normalizedCorrection) next.correction = normalizedCorrection;
-        else delete next.correction;
-        return next;
-      })
-    };
-    append(revision);
-    return revision;
-  };
-  const store = {
-    snapshot() {
-      syncToSession();
-      return interviews;
-    },
-    recordFinalizedInterview(policy) {
-      const entry = finalizedInterviewEntryFields(policy);
-      if (entry === null) return false;
-      append(entry);
-      return true;
-    },
-    recordAgentDecision(input) {
-      syncToSession();
-      let superseded = null;
-      for (const interview of interviews) {
-        const prior = interview.decisions.find((decision) => decision.key === input.key && decision.status === "active");
-        if (prior === void 0) continue;
-        if (interview.origin !== "agent" || prior.source !== "agent") {
-          throw new Error(
-            `decision board: '${input.key}' is an operator decision (${interview.interviewId}); it can only be revised through ask_user`
-          );
-        }
-        superseded = { interviewId: interview.interviewId, key: prior.key };
-        break;
-      }
-      if (superseded !== null) revise(superseded.interviewId, superseded.key, "agent", input.rationale);
-      const now = (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
-      const entries = deps.readEntries?.() ?? [];
-      const parentTurnId = deps.getActiveLeafTurnId?.() ?? activeLeafFromEntries(entries);
-      if (!parentTurnId) throw new Error("decision board: no active branch leaf is available for the decision");
-      const entry = {
-        kind: "decisionLedger",
-        parentTurnId,
-        origin: "agent",
-        interviewId: `agent:${randomUUID()}`,
-        interviewStatus: "complete",
-        startedAt: now,
-        endedAt: now,
-        roundCount: 0,
-        exposure: "local",
-        decisions: [
-          {
-            key: input.key,
-            value: input.value,
-            ...input.label ? { label: input.label } : {},
-            status: "active",
-            decidedAt: now,
-            source: "agent",
-            alternatives: [...input.alternatives],
-            rationale: input.rationale
-          }
-        ]
-      };
-      append(entry);
-      return { entry, superseded };
-    },
-    supersede(interviewId, key, correction) {
-      return revise(interviewId, key, "operator", correction);
-    },
-    invalidate() {
-      dirty = true;
-    }
-  };
-  return store;
-}
-function decisionRationale(decision) {
-  const parts = [];
-  if (decision.alternatives?.length) parts.push(`Alternatives: ${decision.alternatives.join("; ")}`);
-  if (decision.rationale) parts.push(`Rationale: ${decision.rationale}`);
-  if (parts.length > 0) return parts.join(". ");
-  return decision.source_question ?? decision.correction;
-}
-
-export {
-  EVENT_TEE_LIMIT,
-  startDispatchEventPump,
-  WORKER_OUTPUT_MAX_BYTES,
-  workerOutputCaptureBytes,
-  durableAssistantTextFromEvent,
-  createWorkerOutputCapture,
-  AdmissionCanceledError,
-  activeDecisionRefs,
-  foldDecisionBoard,
-  createDecisionBoardStore,
-  decisionRationale
-};
-//# sourceMappingURL=chunk-IGLVVNEG.js.map