@obversa/runtime 0.1.0 → 0.2.1

package/dist/chunk-XDMDT67Q.js

@@ -0,0 +1,598 @@
+import { mkdirSync, writeFileSync, readFileSync, appendFileSync } from 'fs';
+import { randomBytes } from 'crypto';
+import { homedir } from 'os';
+import { join } from 'path';
+
+// src/runtime/supervisor.ts
+var NOISE = /* @__PURE__ */ new Set([
+  "engine:text",
+  "engine:thinking"
+]);
+function runsHome() {
+  return join(process.env.OBVERSA_HOME ?? join(homedir(), ".obversa"), "runs");
+}
+function slug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || "run";
+}
+function newRunId(title) {
+  return `${slug(title)}-${randomBytes(3).toString("hex")}`;
+}
+function startSupervisor(input) {
+  const dir = join(runsHome(), input.runId);
+  const eventsPath = join(dir, "events.jsonl");
+  const proofsPath = join(dir, "proofs.jsonl");
+  const statusPath = join(dir, "status.json");
+  mkdirSync(dir, { recursive: true });
+  writeBestEffort(eventsPath, "");
+  writeBestEffort(proofsPath, "");
+  const startedAt = Date.now();
+  const status = {
+    runId: input.runId,
+    pid: process.pid,
+    cwd: input.cwd,
+    title: input.title,
+    startedAt,
+    updatedAt: startedAt,
+    status: "running",
+    shape: input.shape,
+    live: {
+      path: [],
+      iteration: 0,
+      usage: {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        calls: 0,
+        unmeasuredCalls: 0
+      }
+    }
+  };
+  const active = /* @__PURE__ */ new Map();
+  let proofCount = 0;
+  const writeStatus = () => {
+    status.updatedAt = Date.now();
+    writeBestEffort(statusPath, JSON.stringify(status, null, 2));
+  };
+  const refreshCurrent = () => {
+    status.live.active = active.size ? Object.fromEntries(active.entries()) : void 0;
+    status.live.current = [...active.values()].sort((a, b) => {
+      const deadline = (a.deadlineAt ?? Number.POSITIVE_INFINITY) - (b.deadlineAt ?? Number.POSITIVE_INFINITY);
+      return deadline || b.startedAt - a.startedAt;
+    })[0];
+  };
+  const activeKey = (kind, path) => `${kind}:${path.join("\0")}`;
+  writeStatus();
+  const sink = (event) => {
+    if (!NOISE.has(event.kind)) appendBestEffort(eventsPath, event);
+    switch (event.kind) {
+      case "run:end":
+        status.live.lastOutcome = outcomeSummary(event.outcome);
+        break;
+      case "loop:iteration":
+        status.live.path = event.path;
+        status.live.iteration = event.iteration;
+        break;
+      case "loop:condition":
+        status.live.lastGate = {
+          which: event.which,
+          met: event.result.met,
+          confidence: event.result.confidence,
+          reason: event.result.reason
+        };
+        break;
+      case "condition:result":
+        status.live.lastGate = {
+          which: event.label,
+          met: event.result.met,
+          confidence: event.result.confidence,
+          reason: event.result.reason
+        };
+        break;
+      case "dag:node": {
+        const path = [...event.path, event.node];
+        status.live.path = path;
+        if (event.phase === "start") {
+          active.set(activeKey("dag-node", path), {
+            kind: "dag-node",
+            path,
+            node: event.node,
+            startedAt: event.ts,
+            timeoutMs: event.timeoutMs,
+            deadlineAt: event.timeoutMs ? event.ts + event.timeoutMs : void 0
+          });
+        } else {
+          active.delete(activeKey("dag-node", path));
+        }
+        refreshCurrent();
+        break;
+      }
+      case "job:start": {
+        const path = [...event.path, event.label];
+        active.set(activeKey("job", path), {
+          kind: "job",
+          path: event.path,
+          label: event.label,
+          startedAt: event.ts,
+          timeoutMs: event.timeoutMs,
+          deadlineAt: event.timeoutMs ? event.ts + event.timeoutMs : void 0
+        });
+        refreshCurrent();
+        break;
+      }
+      case "loop:end":
+      case "dag:end":
+      case "job:end":
+        status.live.path = event.path;
+        status.live.lastOutcome = outcomeSummary(event.outcome);
+        if (event.kind === "job:end") {
+          active.delete(activeKey("job", [...event.path, event.label]));
+          refreshCurrent();
+        }
+        break;
+      case "engine:usage":
+        status.live.usage.calls += 1;
+        if (event.usage.kind === "unknown") {
+          status.live.usage.unmeasuredCalls += 1;
+        } else {
+          status.live.usage.inputTokens += event.usage.inputTokens;
+          status.live.usage.outputTokens += event.usage.outputTokens;
+          status.live.usage.cacheReadInputTokens += event.usage.cacheReadInputTokens ?? 0;
+          status.live.usage.cacheCreationInputTokens += event.usage.cacheCreationInputTokens ?? 0;
+        }
+        break;
+      case "proof": {
+        const proof = {
+          name: event.name,
+          path: event.path,
+          artifact: event.artifact
+        };
+        proofCount += 1;
+        appendBestEffort(proofsPath, proof);
+        status.evidence = {
+          count: proofCount,
+          indexPath: proofsPath,
+          latest: proof
+        };
+        break;
+      }
+    }
+    if (!NOISE.has(event.kind)) writeStatus();
+  };
+  const finish = (outcome) => {
+    status.status = outcome.status;
+    status.endedAt = Date.now();
+    status.live.current = void 0;
+    status.live.active = void 0;
+    status.live.lastOutcome = outcomeSummary(outcome);
+    writeStatus();
+  };
+  return { runId: input.runId, dir, sink, finish };
+}
+function outcomeSummary(outcome) {
+  return {
+    status: outcome.status,
+    summary: outcome.summary,
+    late: outcome.late
+  };
+}
+function writeBestEffort(path, text) {
+  try {
+    writeFileSync(path, text);
+  } catch {
+  }
+}
+function appendBestEffort(path, value) {
+  try {
+    appendFileSync(path, `${JSON.stringify(value)}
+`);
+  } catch {
+  }
+}
+function runningTotal(totals) {
+  const read = totals.cacheReadInputTokens ?? 0;
+  const unmeasured = totals.unmeasuredCalls ?? 0;
+  const missing = unmeasured > 0 ? `, usage unknown on ${unmeasured} call${unmeasured === 1 ? "" : "s"}` : "";
+  const base = `${totals.inputTokens}/${totals.outputTokens} tok`;
+  return `${base}${read > 0 ? `, ${read} tok from cache` : ""}${missing}`;
+}
+function toLine(value) {
+  return value.replace(/[\u0000-\u001f\u007f]+/g, " ");
+}
+function formatEvent(event, totals) {
+  return toLine(renderEvent(event, totals));
+}
+function renderEvent(event, totals) {
+  const at = event.path.length ? `${event.path.join(" \u203A ")} ` : "";
+  switch (event.kind) {
+    case "run:start":
+      return "\u25B8 run";
+    case "run:end":
+      return `\u25C2 run ${event.outcome.status}${event.outcome.late ? " late" : ""} (${runningTotal(event.usage)})`;
+    case "loop:start":
+      return `${at}\u25B8 loop${event.max ? ` (max ${event.max})` : ""}`;
+    case "dag:start":
+      return `${at}\u25B8 dag (${event.nodes.length} nodes)`;
+    case "loop:iteration":
+      return `${at}\xB7 iteration ${event.iteration}`;
+    case "loop:condition":
+      return `${at}\xB7 ${event.which} ${event.result.met ? "met" : "not met"}: ${event.result.reason}`;
+    case "condition:result":
+      return `${at}\xB7 ${event.label} ${event.result.met ? "met" : "not met"}: ${event.result.reason}`;
+    case "loop:review":
+      return `${at}\xB7 review: ${event.outcome.status}${event.outcome.late ? " late" : ""}`;
+    case "loop:end":
+      return `${at}\u25C2 ${event.outcome.status}${event.outcome.late ? " late" : ""} (${event.iterations} iter)`;
+    case "dag:node":
+      return `${at}\xB7 node ${event.node}: ${event.phase}${event.outcome ? ` (${event.outcome.status}${event.outcome.late ? " late" : ""})` : ""}`;
+    case "dag:kickback":
+      return `${at}\u21A9 kickback ${event.accepted ? "accepted" : "rejected"} ${event.from} -> ${event.to} [${event.count}/${event.limit}]: ${event.reason}${event.note ? ` (${event.note})` : ""}`;
+    case "dag:end":
+      return `${at}\u25C2 dag ${event.outcome.status}${event.outcome.late ? " late" : ""}`;
+    case "job:start":
+      return `${at}\u2022 ${event.label}`;
+    case "advisor:consult":
+      return `${at}\u25C7 advisor ${event.label} #${event.call}: ${event.question}`;
+    case "proof":
+      return `${at}\u25C8 proof ${event.name}: ${event.artifact.title ?? event.artifact.path ?? event.artifact.kind}`;
+    case "job:end": {
+      const summary = event.outcome.summary ? `  ${event.outcome.summary}` : "";
+      return `${at}\u2022 ${event.label}: ${event.outcome.status}${event.outcome.late ? " late" : ""}${summary}`;
+    }
+    case "engine:text":
+    case "engine:thinking":
+      return "";
+    case "engine:tool":
+      return `${at}  tool ${event.name} ${event.phase}${event.target ? ` ${event.target}` : ""}`;
+    case "engine:usage": {
+      const call = event.usage.kind === "unknown" ? "usage unknown" : `${event.usage.inputTokens}/${event.usage.outputTokens} tok`;
+      return `${at}  ${event.model}: ${call}${totals ? ` (run ${runningTotal(totals)})` : ""}`;
+    }
+    case "refine:judge":
+      return `${at}\u25C6 ${event.reason}`;
+    case "loop:stall":
+      return `${at}\u23F9 stalled after ${event.report.iterations.length} no-progress iterations: ${event.report.reason}`;
+    case "limit:wait":
+      return `${at}\u23F8 limit ${event.code}: waiting ${Math.round(event.waitMs / 1e3)}s`;
+    case "limit:pause":
+      return `${at}\u23F8 paused (${event.code}): ${event.reason}`;
+    case "log":
+      return `${at}${event.message}`;
+    case "error":
+      return `${at}\u2717 ${event.code}: ${event.message}`;
+    default:
+      return `${at}${event.kind}`;
+  }
+}
+var DEFAULT_WIDTH = 100;
+function firstLine(value) {
+  for (const raw of value.split("\n")) {
+    const line = toLine(raw).trim().replace(/^(?:[-*]|\d+\.)\s+/, "");
+    if (line.length > 0) return line;
+  }
+  return "";
+}
+function outcomeOf(outcome) {
+  return outcome ? { status: outcome.status, summary: outcome.summary } : null;
+}
+function summarizeRecord(events) {
+  const firstDag = events.find((e) => e.kind === "dag:start");
+  const rootDepth = firstDag && firstDag.kind === "dag:start" ? firstDag.path.length : 0;
+  let name = null;
+  let startedAt = null;
+  let endedAt = null;
+  let outcome = null;
+  let usage = null;
+  let monitor = null;
+  const nodes = [];
+  const lines = [];
+  const measured = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    unmeasuredCalls: 0
+  };
+  const nodeFor = (name_) => {
+    let n = nodes.find((x) => x.node === name_);
+    if (!n) {
+      n = { node: name_, runs: [] };
+      nodes.push(n);
+    }
+    return n;
+  };
+  const runFor = (nodeName, attempt) => {
+    const n = nodeFor(nodeName);
+    let r = n.runs.find((x) => x.attempt === attempt);
+    if (!r) {
+      r = {
+        attempt,
+        startedAt: null,
+        endedAt: null,
+        outcome: null,
+        kickback: null,
+        engineCalls: [],
+        tools: [],
+        lines: []
+      };
+      n.runs.push(r);
+      n.runs.sort((a, b) => a.attempt - b.attempt);
+    }
+    return r;
+  };
+  const latestRun = (nodeName) => {
+    const n = nodeFor(nodeName);
+    const last = n.runs[n.runs.length - 1];
+    if (last) return last;
+    return runFor(nodeName, 1);
+  };
+  for (const event of events) {
+    if (startedAt === null) startedAt = event.ts;
+    if (event.kind === "dag:node" && event.path.length === rootDepth) {
+      const run = runFor(event.node, event.attempt ?? 1);
+      if (event.phase === "start") {
+        run.startedAt = event.ts;
+      } else {
+        run.endedAt = event.ts;
+        if (event.phase === "skip") {
+          run.outcome = { status: "skipped", summary: event.outcome?.summary };
+        } else if (event.outcome) {
+          run.outcome = outcomeOf(event.outcome) ?? run.outcome;
+          if (event.outcome.status === "paused" && event.outcome.summary && !run.lines.some((l) => l.kind === "paused")) {
+            run.lines.push({ kind: "paused", text: `Paused: ${event.outcome.summary}` });
+          }
+        }
+      }
+      continue;
+    }
+    if (event.path.length > rootDepth) {
+      const run = latestRun(event.path[rootDepth] ?? "");
+      switch (event.kind) {
+        case "engine:usage": {
+          if (event.usage.kind === "reported") {
+            run.engineCalls.push({
+              model: event.model,
+              inputTokens: event.usage.inputTokens,
+              outputTokens: event.usage.outputTokens
+            });
+            measured.inputTokens += event.usage.inputTokens;
+            measured.outputTokens += event.usage.outputTokens;
+            measured.cacheReadInputTokens += event.usage.cacheReadInputTokens ?? 0;
+          } else {
+            run.engineCalls.push({ model: event.model, inputTokens: null, outputTokens: null });
+            measured.unmeasuredCalls += 1;
+          }
+          break;
+        }
+        case "engine:tool": {
+          if (event.phase === "use") {
+            const existing = run.tools.find((t) => t.name === event.name);
+            if (existing) {
+              existing.count += 1;
+              if (event.target !== void 0 && !existing.targets.includes(event.target)) {
+                existing.targets.push(event.target);
+              }
+            } else {
+              run.tools.push({
+                name: event.name,
+                count: 1,
+                targets: event.target !== void 0 ? [event.target] : []
+              });
+            }
+          }
+          break;
+        }
+        case "limit:pause":
+          run.lines.push({ kind: event.kind, text: `Paused (${event.code}): ${event.reason}` });
+          break;
+        case "dag:node":
+          if (event.phase !== "start") {
+            const status = event.phase === "skip" ? "skipped" : event.outcome?.status ?? "no end recorded";
+            const summary = event.outcome?.summary ? firstLine(event.outcome.summary) : "";
+            const label = [...event.path.slice(rootDepth + 1), event.node].join("/");
+            run.lines.push({ kind: event.kind, text: `${label}: ${status}${summary ? `, ${summary}` : ""}` });
+          }
+          break;
+        case "log":
+          run.lines.push({ kind: event.kind, text: `log: ${event.message}` });
+          break;
+        case "error":
+          run.lines.push({ kind: event.kind, text: `error ${event.code}: ${event.message}` });
+          break;
+        case "job:start":
+        case "job:end":
+        case "engine:text":
+        case "engine:thinking":
+        case "dag:start":
+        case "dag:end":
+          break;
+        default:
+          run.lines.push({ kind: event.kind, text: event.kind });
+      }
+      continue;
+    }
+    switch (event.kind) {
+      case "run:start":
+        if (name === null && event.runId) name = event.runId;
+        break;
+      case "run:end":
+        endedAt = event.ts;
+        outcome = outcomeOf(event.outcome);
+        usage = {
+          inputTokens: event.usage.inputTokens,
+          outputTokens: event.usage.outputTokens,
+          cacheReadInputTokens: event.usage.cacheReadInputTokens ?? 0,
+          unmeasuredCalls: event.usage.unmeasuredCalls ?? 0
+        };
+        break;
+      case "dag:start":
+        if (name === null && event.path.length > 0) name = event.path[0] ?? null;
+        break;
+      case "dag:end":
+        break;
+      case "monitor":
+        monitor = event.url;
+        break;
+      case "dag:kickback":
+        if (event.accepted) {
+          const run = runFor(event.to, event.count + 1);
+          run.kickback = {
+            from: event.from,
+            to: event.to,
+            reason: event.reason,
+            count: event.count,
+            limit: event.limit,
+            accepted: true,
+            note: event.note
+          };
+        } else {
+          latestRun(event.to).lines.push({
+            kind: event.kind,
+            text: `Kickback from ${event.from} rejected${event.note ? ` (${event.note})` : ""}: ${event.reason}`
+          });
+        }
+        break;
+      case "log":
+        lines.push({ kind: event.kind, text: `log: ${event.message}` });
+        break;
+      case "error":
+        lines.push({ kind: event.kind, text: `error ${event.code}: ${event.message}` });
+        break;
+      default:
+        lines.push({ kind: event.kind, text: event.kind });
+    }
+  }
+  if (name === null && firstDag && firstDag.kind === "dag:start" && firstDag.path.length > 0) {
+    name = firstDag.path[0] ?? null;
+  }
+  return {
+    name,
+    startedAt,
+    endedAt,
+    outcome,
+    usage: usage ?? measured,
+    monitor,
+    nodes: nodes.map((n) => ({
+      node: n.node,
+      runs: n.runs.map((r) => ({
+        attempt: r.attempt,
+        startedAt: r.startedAt,
+        endedAt: r.endedAt,
+        outcome: r.outcome,
+        kickback: r.kickback,
+        engineCalls: r.engineCalls,
+        tools: r.tools.map((t) => ({ name: t.name, count: t.count, targets: t.targets })),
+        lines: r.lines
+      }))
+    })),
+    lines
+  };
+}
+var commas = (n) => `${n}`.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+function clockTime(ts) {
+  return new Date(ts).toISOString().slice(11, 19);
+}
+function headerTime(ts) {
+  return `${new Date(ts).toISOString().slice(0, 19).replace("T", " ")} UTC`;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms} ms`;
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${s % 60}s`;
+  return `${Math.floor(m / 60)}h ${m % 60}m`;
+}
+function fit(text, width) {
+  return text.length > width ? `${text.slice(0, width)}\u2026` : text;
+}
+function renderRecord(events, options) {
+  const width = options?.lineWidth ?? DEFAULT_WIDTH;
+  const summary = summarizeRecord(events);
+  const out = [];
+  out.push(`# ${summary.name ?? "run"}`);
+  out.push("");
+  if (summary.startedAt !== null && summary.endedAt === null) {
+    out.push(`- Started ${headerTime(summary.startedAt)}. No end recorded.`);
+  } else if (summary.startedAt !== null && summary.endedAt !== null) {
+    out.push(
+      `- Started ${headerTime(summary.startedAt)}, ended ${headerTime(summary.endedAt)} after ${formatDuration(summary.endedAt - summary.startedAt)}.`
+    );
+    if (summary.outcome) {
+      const text = summary.outcome.summary ? `${summary.outcome.status}. ${fit(firstLine(summary.outcome.summary), width)}` : `${summary.outcome.status}.`;
+      out.push(`- Outcome: ${text}`);
+    }
+  }
+  const usageParts = [`${commas(summary.usage.inputTokens)} in, ${commas(summary.usage.outputTokens)} out`];
+  if (summary.usage.cacheReadInputTokens > 0) {
+    usageParts.push(`${commas(summary.usage.cacheReadInputTokens)} read from cache`);
+  }
+  let tokensLine = `- Tokens: ${usageParts.join(", ")}.`;
+  if (summary.usage.unmeasuredCalls > 0) {
+    tokensLine = `- Tokens: ${usageParts.join(", ")}, usage unknown on ${summary.usage.unmeasuredCalls} calls.`;
+  }
+  out.push(tokensLine);
+  if (summary.monitor) out.push(`- Monitor: ${summary.monitor}`);
+  for (const line of summary.lines) out.push(`- ${fit(line.text, width)}`);
+  for (const node of summary.nodes) {
+    out.push("");
+    out.push(`## ${node.node}`);
+    for (const run of node.runs) {
+      out.push("");
+      if (run.kickback) {
+        out.push(
+          `Kickback from ${run.kickback.from}, ${run.kickback.count} of ${run.kickback.limit}: ${run.kickback.reason}`
+        );
+        out.push("");
+      }
+      const status = run.endedAt === null ? "no end recorded" : run.outcome?.status ?? "no outcome";
+      const parts = [`### Run ${run.attempt}: ${status}`];
+      if (run.startedAt !== null && run.endedAt !== null) {
+        parts.push(formatDuration(run.endedAt - run.startedAt));
+      }
+      if (run.startedAt !== null) parts.push(`started ${clockTime(run.startedAt)}`);
+      else if (run.endedAt !== null) parts.push(`at ${clockTime(run.endedAt)}`);
+      out.push(parts.join(", "));
+      if (run.outcome?.summary) {
+        out.push("");
+        out.push(fit(firstLine(run.outcome.summary), width));
+      }
+      if (run.engineCalls.length > 0 || run.tools.length > 0 || run.lines.length > 0) {
+        out.push("");
+        for (const call of run.engineCalls) {
+          out.push(
+            call.inputTokens === null || call.outputTokens === null ? `- ${call.model}: usage unknown` : `- ${call.model}: ${commas(call.inputTokens)} in, ${commas(call.outputTokens)} out`
+          );
+        }
+        if (run.tools.length > 0) {
+          out.push(
+            `- ${run.tools.map((t) => `${t.name} \xD7${t.count}${t.targets.length > 0 ? `: ${t.targets.join(", ")}` : ""}`).join(", ")}`
+          );
+        }
+        for (const line of run.lines) {
+          const uncut = line.kind === "paused" || line.kind === "limit:pause";
+          out.push(`- ${uncut ? line.text : fit(line.text, width)}`);
+        }
+      }
+    }
+  }
+  return `${out.join("\n")}
+`;
+}
+function readRecordFile(path) {
+  const text = readFileSync(path, "utf8");
+  const events = [];
+  let unreadable = 0;
+  for (const line of text.split(/\r?\n/)) {
+    if (line.trim().length === 0) continue;
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+      unreadable += 1;
+    }
+  }
+  return { events, unreadable };
+}
+
+export { formatEvent, newRunId, readRecordFile, renderRecord, runningTotal, startSupervisor, summarizeRecord };
+//# sourceMappingURL=chunk-XDMDT67Q.js.map
+//# sourceMappingURL=chunk-XDMDT67Q.js.map