@inhuman.tools/harness 0.0.0-stage → 0.1.0

package/dist/tui/paint-dom.js

@@ -0,0 +1,709 @@
+import equal from "fast-deep-equal";
+import { detach, types } from "mobx-state-tree";
+function lateNode() {
+    return PaintNode;
+}
+/** Replica / identity can hand `null` on first paint. MST strings refuse it. */
+function faceText(value) {
+    return typeof value === "string" ? value : "";
+}
+const paintChildren = types.array(types.late(lateNode));
+const SpeechPaint = types
+    .model("SpeechPaint", {
+    kind: types.literal("speech"),
+    text: types.optional(types.string, ""),
+    voice: types.optional(types.enumeration(["user", "assistant"]), "assistant"),
+    atMs: types.optional(types.maybeNull(types.number), null),
+    /** Selected pin: chrome_frame plus session-title annotation. */
+    recap: types.optional(types.boolean, false),
+    recapHotkeys: types.optional(types.frozen(), []),
+    annotation: types.optional(types.string, ""),
+})
+    .actions((self) => ({
+    updateText(next) {
+        if (self.text === next)
+            return;
+        self.text = next;
+    },
+    setVoice(next) {
+        if (self.voice === next)
+            return;
+        self.voice = next;
+    },
+    setAtMs(next) {
+        if (self.atMs === next)
+            return;
+        self.atMs = next;
+    },
+    setRecap(next, annotation = "", hotkeys = []) {
+        if (self.recap === next && self.annotation === annotation && equal(self.recapHotkeys, hotkeys))
+            return;
+        self.recapHotkeys = next ? hotkeys : [];
+        self.recap = next;
+        self.annotation = next ? annotation : "";
+    },
+}));
+const ThinkingPaint = types
+    .model("ThinkingPaint", {
+    kind: types.literal("thinking"),
+    text: types.optional(types.string, ""),
+})
+    .actions((self) => ({
+    updateText(next) {
+        if (self.text === next)
+            return;
+        self.text = next;
+    },
+}));
+const FailurePaint = types
+    .model("FailurePaint", {
+    kind: types.literal("failure"),
+    endDetail: types.optional(types.string, ""),
+    failReason: types.optional(types.string, ""),
+})
+    .actions((self) => ({
+    updateEndDetail(next) {
+        if (self.endDetail === next)
+            return;
+        self.endDetail = next;
+    },
+    updateFailReason(next) {
+        if (self.failReason === next)
+            return;
+        self.failReason = next;
+    },
+}));
+const RecallPaint = types
+    .model("RecallPaint", {
+    kind: types.enumeration(["recall", "compact"]),
+    text: types.optional(types.string, ""),
+})
+    .actions((self) => ({
+    updateText(next) {
+        if (self.text === next)
+            return;
+        self.text = next;
+    },
+}));
+const WorkCellPaint = types
+    .model("WorkCellPaint", {
+    kind: types.enumeration(["tool", "scheme", "loop", "ask", "wait"]),
+    toolCallId: types.optional(types.string, ""),
+    name: types.optional(types.string, ""),
+    object: types.optional(types.string, ""),
+    status: types.optional(types.string, ""),
+    caption: types.optional(types.string, ""),
+    state: types.optional(types.enumeration(["live", "ok", "fail", "ask", "judging"]), "live"),
+    indent: types.optional(types.boolean, false),
+    split: types.optional(types.boolean, false),
+    agent: types.optional(types.boolean, false),
+    pretty: types.optional(types.boolean, false),
+    prettyBlock: types.optional(types.string, ""),
+    response: types.optional(types.string, ""),
+    receiptKind: types.optional(types.enumeration([
+        "none",
+        "text",
+        "markdown",
+        "diff",
+        "stream",
+        "syntax",
+        "number",
+        "boolean",
+        "parts",
+    ]), "none"),
+    receiptText: types.optional(types.string, ""),
+    diffOld: types.optional(types.string, ""),
+    diffNew: types.optional(types.string, ""),
+    diffPath: types.optional(types.string, ""),
+    diffLineStart: types.optional(types.number, 0),
+    /** see tape-spans.ts preamble, CHANGE ONLY. */
+    fuse: types.optional(types.boolean, false),
+    /** Wait pin: epoch ms when this occupancy row first appeared. Write-once. */
+    startedAt: types.optional(types.maybeNull(types.number), null),
+    /** Live backoff until this epoch ms. Wait pin only. */
+    retryUntilMs: types.optional(types.maybeNull(types.number), null),
+    children: types.optional(paintChildren, []),
+})
+    .actions((self) => ({
+    setFace(next) {
+        if (next.toolCallId !== undefined) {
+            const toolCallId = faceText(next.toolCallId);
+            if (self.toolCallId !== toolCallId)
+                self.toolCallId = toolCallId;
+        }
+        const name = faceText(next.name);
+        const object = faceText(next.object);
+        const status = faceText(next.status);
+        if (self.name !== name)
+            self.name = name;
+        if (self.object !== object)
+            self.object = object;
+        if (self.status !== status)
+            self.status = status;
+        if (next.caption !== undefined) {
+            const caption = faceText(next.caption);
+            if (self.caption !== caption)
+                self.caption = caption;
+        }
+        if (self.state !== next.state)
+            self.state = next.state;
+        if (self.indent !== next.indent)
+            self.indent = next.indent;
+        if (next.split !== undefined && self.split !== next.split)
+            self.split = next.split;
+        if (next.agent !== undefined && self.agent !== next.agent)
+            self.agent = next.agent;
+        if (next.pretty !== undefined && self.pretty !== next.pretty)
+            self.pretty = next.pretty;
+        if (next.prettyBlock !== undefined) {
+            const prettyBlock = faceText(next.prettyBlock);
+            if (self.prettyBlock !== prettyBlock)
+                self.prettyBlock = prettyBlock;
+        }
+        if (next.response !== undefined) {
+            const response = faceText(next.response);
+            if (self.response !== response)
+                self.response = response;
+        }
+        if (self.receiptKind !== next.receiptKind)
+            self.receiptKind = next.receiptKind;
+        const receiptText = faceText(next.receiptText);
+        const diffOld = faceText(next.diffOld);
+        const diffNew = faceText(next.diffNew);
+        const diffPath = faceText(next.diffPath);
+        if (self.receiptText !== receiptText)
+            self.receiptText = receiptText;
+        if (self.diffOld !== diffOld)
+            self.diffOld = diffOld;
+        if (self.diffNew !== diffNew)
+            self.diffNew = diffNew;
+        if (self.diffPath !== diffPath)
+            self.diffPath = diffPath;
+        if (next.diffLineStart !== undefined && self.diffLineStart !== next.diffLineStart) {
+            self.diffLineStart = next.diffLineStart;
+        }
+        if (next.fuse !== undefined && self.fuse !== next.fuse)
+            self.fuse = next.fuse;
+        if (next.startedAt != null && Number.isFinite(next.startedAt) && self.startedAt == null) {
+            self.startedAt = next.startedAt;
+        }
+        if (next.retryUntilMs !== undefined) {
+            const retryUntilMs = next.retryUntilMs != null && Number.isFinite(next.retryUntilMs) ? next.retryUntilMs : null;
+            if (self.retryUntilMs !== retryUntilMs)
+                self.retryUntilMs = retryUntilMs;
+        }
+    },
+}));
+const CompletionPaint = types
+    .model("CompletionPaint", {
+    kind: types.literal("completion"),
+    state: types.optional(types.enumeration(["live", "successful", "failed"]), "live"),
+    workerPresent: types.optional(types.boolean, false),
+    model: types.optional(types.string, ""),
+    startedAt: types.optional(types.maybeNull(types.number), null),
+    durationMs: types.optional(types.maybeNull(types.number), null),
+    thoughtLive: types.optional(types.boolean, false),
+    /** Live backoff until this epoch ms. Null when not waiting to retry. */
+    retryUntilMs: types.optional(types.maybeNull(types.number), null),
+    /** `summary` when the visible thought is a provider summary, not CoT. */
+    thoughtKind: types.optional(types.string, ""),
+    /** DEBUG=* cache-invariant mark. Empty when aligned or not debug. */
+    debugNote: types.optional(types.string, ""),
+    children: types.optional(paintChildren, []),
+})
+    .actions((self) => ({
+    setState(next) {
+        if (self.state === next)
+            return;
+        self.state = next;
+    },
+    setWorkerPresent(next) {
+        if (self.workerPresent === next)
+            return;
+        self.workerPresent = next;
+    },
+    setModel(next) {
+        if (self.model === next)
+            return;
+        self.model = next;
+    },
+    setStartedAt(next) {
+        if (self.startedAt === next)
+            return;
+        self.startedAt = next;
+    },
+    setDurationMs(next) {
+        if (self.durationMs === next)
+            return;
+        self.durationMs = next;
+    },
+    setThoughtLive(next) {
+        if (self.thoughtLive === next)
+            return;
+        self.thoughtLive = next;
+    },
+    setRetryUntilMs(next) {
+        if (self.retryUntilMs === next)
+            return;
+        self.retryUntilMs = next;
+    },
+    setThoughtKind(next) {
+        if (self.thoughtKind === next)
+            return;
+        self.thoughtKind = next;
+    },
+    setDebugNote(next) {
+        if (self.debugNote === next)
+            return;
+        self.debugNote = next;
+    },
+}));
+function childHostActions(self) {
+    return {
+        appendChild(node) {
+            self.children.push(node);
+        },
+        insertChildAt(index, node) {
+            self.children.splice(index, 0, node);
+        },
+        removeChildAt(index) {
+            self.children.splice(index, 1);
+        },
+        /** Reorder without MST-killing the node. splice-remove destroys; detach does not. */
+        placeChild(index, node) {
+            if (self.children[index] === node)
+                return;
+            const at = self.children.indexOf(node);
+            if (at !== -1)
+                detach(self.children[at]);
+            self.children.splice(index, 0, node);
+        },
+    };
+}
+const TurnPaint = types
+    .model("TurnPaint", {
+    kind: types.literal("turn"),
+    children: types.optional(paintChildren, []),
+})
+    .actions((self) => childHostActions(self));
+const StackPaint = types
+    .model("StackPaint", {
+    kind: types.literal("stack"),
+    children: types.optional(paintChildren, []),
+})
+    .actions((self) => childHostActions(self));
+const PreviewPaint = types
+    .model("PreviewPaint", {
+    kind: types.literal("preview"),
+    children: types.optional(paintChildren, []),
+})
+    .actions((self) => childHostActions(self));
+const RewindPaint = types
+    .model("RewindPaint", {
+    kind: types.literal("rewind"),
+    atTip: types.optional(types.boolean, true),
+    seatRim: types.optional(types.boolean, true),
+    past: types.optional(types.frozen(), []),
+    future: types.optional(types.frozen(), []),
+    pastTotal: types.optional(types.number, 0),
+    futureTotal: types.optional(types.number, 0),
+})
+    .actions((self) => ({
+    setFace(atTip, past, future, pastTotal = past.length, futureTotal = future.length, seatRim = atTip) {
+        if (self.atTip === atTip &&
+            self.seatRim === seatRim &&
+            self.pastTotal === pastTotal &&
+            self.futureTotal === futureTotal &&
+            equal(self.past, past) &&
+            equal(self.future, future)) {
+            return;
+        }
+        self.atTip = atTip;
+        self.seatRim = seatRim;
+        self.past = past;
+        self.future = future;
+        self.pastTotal = pastTotal;
+        self.futureTotal = futureTotal;
+    },
+}));
+export const RootPaint = types
+    .model("RootPaint", {
+    kind: types.literal("root"),
+    children: types.optional(paintChildren, []),
+})
+    .actions((self) => childHostActions(self));
+const StatuslinePaint = types
+    .model("StatuslinePaint", {
+    kind: types.literal("statusline"),
+    cwd: types.optional(types.string, ""),
+    /** Bright prefix of `cwd` (git root). Empty = paint `cwd` as one span. */
+    cwdRoot: types.optional(types.string, ""),
+    left: types.optional(types.string, ""),
+    /** Checkout clause, quieter than `left`. Empty omits it. */
+    note: types.optional(types.string, ""),
+})
+    .actions((self) => ({
+    setCwd(next) {
+        if (self.cwd === next)
+            return;
+        self.cwd = next;
+    },
+    setCwdRoot(next) {
+        if (self.cwdRoot === next)
+            return;
+        self.cwdRoot = next;
+    },
+    setLeft(next) {
+        if (self.left === next)
+            return;
+        self.left = next;
+    },
+    setNote(next) {
+        if (self.note === next)
+            return;
+        self.note = next;
+    },
+}));
+const AgentsPaint = types
+    .model("AgentsPaint", {
+    kind: types.literal("agents"),
+    meterLeft: types.optional(types.string, ""),
+    meterRight: types.optional(types.string, ""),
+    open: types.optional(types.boolean, false),
+    focusKey: types.optional(types.string, ""),
+    scroll: types.optional(types.number, 0),
+    rows: types.optional(types.frozen(), []),
+    previewKey: types.optional(types.string, ""),
+})
+    .actions((self) => ({
+    setFace(next) {
+        const meterLeft = faceText(next.meterLeft);
+        const meterRight = faceText(next.meterRight);
+        const focusKey = faceText(next.focusKey);
+        const previewKey = faceText(next.previewKey);
+        if (self.meterLeft !== meterLeft)
+            self.meterLeft = meterLeft;
+        if (self.meterRight !== meterRight)
+            self.meterRight = meterRight;
+        if (self.open !== next.open)
+            self.open = next.open;
+        if (self.focusKey !== focusKey)
+            self.focusKey = focusKey;
+        if (self.scroll !== next.scroll)
+            self.scroll = next.scroll;
+        if (!equal(self.rows, next.rows))
+            self.rows = next.rows;
+        if (self.previewKey !== previewKey)
+            self.previewKey = previewKey;
+    },
+}));
+const ComposerPaint = types
+    .model("ComposerPaint", {
+    kind: types.literal("composer"),
+    /** Painted face. Secret mode is already masked; raw secret never lives here. */
+    draft: types.optional(types.string, ""),
+    cursor: types.optional(types.number, 0),
+    mark: types.optional(types.maybeNull(types.number), null),
+    interactive: types.optional(types.boolean, true),
+    readOnly: types.optional(types.boolean, false),
+    mode: types.optional(types.enumeration(["normal", "secret", "isolated", "waiting"]), "normal"),
+    placeholder: types.optional(types.string, ""),
+    annotation: types.optional(types.string, ""),
+    joinAnnotation: types.optional(types.string, ""),
+    hotkeys: types.optional(types.frozen(), []),
+    errorLevel: types.optional(types.maybeNull(types.enumeration(["warning", "error"])), null),
+    errorMessage: types.optional(types.string, ""),
+    statusItems: types.optional(types.frozen(), []),
+    quotaWindows: types.optional(types.frozen(), []),
+    contextUsed: types.optional(types.number, 0),
+    contextLimit: types.optional(types.number, 0),
+    contourRole: types.optional(types.string, ""),
+    progress: types.optional(types.maybeNull(types.number), null),
+    progressColor: types.optional(types.string, ""),
+    progressGlowAt: types.optional(types.maybeNull(types.number), null),
+    progressAnnotation: types.optional(types.string, ""),
+    commandChoices: types.optional(types.maybeNull(types.frozen()), null),
+    commandAction: types.optional(types.maybeNull(types.frozen()), null),
+    selectedCommandKey: types.optional(types.maybeNull(types.string), null),
+    scrollOffset: types.optional(types.number, 0),
+    stackedBody: types.optional(types.string, ""),
+    stackedViewport: types.optional(types.number, 0),
+    stackedNumbered: types.optional(types.boolean, false),
+    stackedLang: types.optional(types.string, ""),
+    children: types.optional(paintChildren, []),
+})
+    .actions((self) => ({
+    setDraft(next) {
+        if (self.draft === next)
+            return;
+        self.draft = next;
+    },
+    setCursor(next) {
+        if (self.cursor === next)
+            return;
+        self.cursor = next;
+    },
+    setMark(next) {
+        if (self.mark === next)
+            return;
+        self.mark = next;
+    },
+    setInteractive(next) {
+        if (self.interactive === next)
+            return;
+        self.interactive = next;
+    },
+    setReadOnly(next) {
+        if (self.readOnly === next)
+            return;
+        self.readOnly = next;
+    },
+    setMode(next) {
+        if (self.mode === next)
+            return;
+        self.mode = next;
+    },
+    setPlaceholder(next) {
+        if (self.placeholder === next)
+            return;
+        self.placeholder = next;
+    },
+    setAnnotation(next) {
+        if (self.annotation === next)
+            return;
+        self.annotation = next;
+    },
+    setJoinAnnotation(next) {
+        if (self.joinAnnotation === next)
+            return;
+        self.joinAnnotation = next;
+    },
+    setHotkeys(next) {
+        if (equal(self.hotkeys, next))
+            return;
+        self.hotkeys = next;
+    },
+    setError(level, message) {
+        if (self.errorLevel === level && self.errorMessage === message)
+            return;
+        self.errorLevel = level;
+        self.errorMessage = message;
+    },
+    setStatusItems(next) {
+        if (equal(self.statusItems, next))
+            return;
+        self.statusItems = next;
+    },
+    setQuotaWindows(next) {
+        if (equal(self.quotaWindows, next))
+            return;
+        self.quotaWindows = next;
+    },
+    setContextUsed(next) {
+        if (self.contextUsed === next)
+            return;
+        self.contextUsed = next;
+    },
+    setContextLimit(next) {
+        if (self.contextLimit === next)
+            return;
+        self.contextLimit = next;
+    },
+    setContourRole(next) {
+        if (self.contourRole === next)
+            return;
+        self.contourRole = next;
+    },
+    setProgress(next) {
+        if (self.progress === next)
+            return;
+        self.progress = next;
+    },
+    setProgressColor(next) {
+        if (self.progressColor === next)
+            return;
+        self.progressColor = next;
+    },
+    setProgressGlowAt(next) {
+        if (self.progressGlowAt === next)
+            return;
+        self.progressGlowAt = next;
+    },
+    setProgressAnnotation(next) {
+        if (self.progressAnnotation === next)
+            return;
+        self.progressAnnotation = next;
+    },
+    setCommandChoices(next) {
+        if (equal(self.commandChoices, next))
+            return;
+        self.commandChoices = next;
+    },
+    setCommandAction(next) {
+        if (equal(self.commandAction, next))
+            return;
+        self.commandAction = next;
+    },
+    setSelectedCommandKey(next) {
+        if (self.selectedCommandKey === next)
+            return;
+        self.selectedCommandKey = next;
+    },
+    setScrollOffset(next) {
+        if (self.scrollOffset === next)
+            return;
+        self.scrollOffset = next;
+    },
+    setStackedBody(next) {
+        if (self.stackedBody === next)
+            return;
+        self.stackedBody = next;
+    },
+    setStackedViewport(next) {
+        if (self.stackedViewport === next)
+            return;
+        self.stackedViewport = next;
+    },
+    setStackedNumbered(next) {
+        if (self.stackedNumbered === next)
+            return;
+        self.stackedNumbered = next;
+    },
+    setStackedLang(next) {
+        if (self.stackedLang === next)
+            return;
+        self.stackedLang = next;
+    },
+    appendChild(node) {
+        self.children.push(node);
+    },
+    removeChildAt(index) {
+        self.children.splice(index, 1);
+    },
+}));
+const KIND = {
+    speech: SpeechPaint,
+    thinking: ThinkingPaint,
+    failure: FailurePaint,
+    recall: RecallPaint,
+    compact: RecallPaint,
+    completion: CompletionPaint,
+    tool: WorkCellPaint,
+    scheme: WorkCellPaint,
+    loop: WorkCellPaint,
+    ask: WorkCellPaint,
+    wait: WorkCellPaint,
+    turn: TurnPaint,
+    stack: StackPaint,
+    preview: PreviewPaint,
+    rewind: RewindPaint,
+    root: RootPaint,
+    composer: ComposerPaint,
+    statusline: StatuslinePaint,
+    agents: AgentsPaint,
+};
+function dispatchPaint(snapshot) {
+    const kind = snapshot !== null && typeof snapshot === "object" && "kind" in snapshot
+        ? String(snapshot.kind)
+        : "";
+    const model = KIND[kind];
+    if (model === undefined) {
+        throw new Error(`unknown paint kind ${kind === "" ? "<missing>" : kind}`);
+    }
+    return model;
+}
+export const PaintNode = types.union({ dispatcher: dispatchPaint }, ...new Set(Object.values(KIND)));
+/** MST `types.late` cannot name the recursive union; the dispatcher already minted each child. */
+export function paintChildrenOf(node) {
+    if (!("children" in node))
+        return [];
+    const { children } = node;
+    if (!Array.isArray(children))
+        return [];
+    return children;
+}
+export function createPaintRoot() {
+    return RootPaint.create({ kind: "root", children: [] });
+}
+export function createCompletion(fields = {}) {
+    return CompletionPaint.create({
+        kind: "completion",
+        state: fields.state ?? "live",
+        workerPresent: fields.workerPresent ?? false,
+        model: fields.model ?? "",
+        startedAt: fields.startedAt ?? null,
+        durationMs: fields.durationMs ?? null,
+        thoughtLive: fields.thoughtLive ?? false,
+        retryUntilMs: fields.retryUntilMs ?? null,
+        thoughtKind: fields.thoughtKind ?? "",
+        children: [
+            { kind: "speech", text: "" },
+            { kind: "thinking", text: "" },
+            { kind: "failure", endDetail: "", failReason: "" },
+        ],
+    });
+}
+export function createTurn() {
+    return TurnPaint.create({ kind: "turn", children: [] });
+}
+export function createStack() {
+    return StackPaint.create({ kind: "stack", children: [] });
+}
+export function createPreview() {
+    return PreviewPaint.create({ kind: "preview", children: [] });
+}
+export function createRewind() {
+    return RewindPaint.create({ kind: "rewind" });
+}
+export function createComposer() {
+    return ComposerPaint.create({ kind: "composer" });
+}
+export function createStatusline() {
+    return StatuslinePaint.create({ kind: "statusline" });
+}
+export function createAgents() {
+    return AgentsPaint.create({ kind: "agents" });
+}
+export function createRecall(text = "") {
+    return RecallPaint.create({ kind: "recall", text });
+}
+export function createCompact(text = "") {
+    return RecallPaint.create({ kind: "compact", text });
+}
+export function createSpeech(text = "", voice = "assistant", atMs = null) {
+    return SpeechPaint.create({ kind: "speech", text, voice, atMs });
+}
+export function createWorkCell(kind) {
+    return WorkCellPaint.create({ kind });
+}
+export function isPaintRootChrome(kind) {
+    return (kind === "composer" ||
+        kind === "ask" ||
+        kind === "wait" ||
+        kind === "statusline" ||
+        kind === "agents" ||
+        kind === "preview" ||
+        kind === "rewind");
+}
+export function speechOf(node) {
+    const child = paintChildrenOf(node).at(0);
+    if (child === undefined || child.kind !== "speech") {
+        throw new Error("completion missing speech child");
+    }
+    return child;
+}
+export function thinkingOf(node) {
+    const child = paintChildrenOf(node).at(1);
+    if (child === undefined || child.kind !== "thinking") {
+        throw new Error("completion missing thinking child");
+    }
+    return child;
+}
+export function failureOf(node) {
+    const child = paintChildrenOf(node).at(2);
+    if (child === undefined || child.kind !== "failure") {
+        throw new Error("completion missing failure child");
+    }
+    return child;
+}
+//# sourceMappingURL=paint-dom.js.map