@thaut/claude-ide 0.0.0-stage → 1.0.0

package/web/src/transcript.test.ts

@@ -0,0 +1,186 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import type { LiveEvent, SdkMessageLike } from "../../shared/protocol.ts";
+import { Transcript, buildItems, type ContentBlock } from "./transcript.ts";
+
+const assistant = (uuid: string, id: string, content: ContentBlock[], parent: string | null = null): SdkMessageLike => ({
+  type: "assistant", uuid, parent_tool_use_id: parent, message: { id, content },
+});
+const sdk = (m: SdkMessageLike): LiveEvent => ({ k: "sdk", m });
+const delta = (msgId: string, index: number, kind: "text" | "thinking", text: string, parent: string | null = null): LiveEvent => ({ k: "delta", msgId, index, kind, text, parent });
+const result = (uuid: string): LiveEvent => sdk({ type: "result", uuid, subtype: "success", duration_ms: 2000, total_cost_usd: 0.1 });
+
+test("history and live messages keep a timestamp for the transcript", () => {
+  const historical = { ...assistant("a", "m1", [{ type: "text", text: "history" }]), timestamp: "2026-10-22T01:02:03.000Z" };
+  const live = assistant("b", "m2", [{ type: "text", text: "live" }]);
+  const items = buildItems([historical], [sdk(live), result("r")]);
+  assert.equal(items[0]!.ts, Date.parse(historical.timestamp));
+  assert.ok(items[1]!.ts && items[1]!.ts! > 0);
+  assert.ok(items[2]!.ts && items[2]!.ts! > 0);
+});
+
+test("replayed results stay between their original turns when history overlaps live messages", () => {
+  const first = assistant("a", "m1", [{ type: "text", text: "first" }]);
+  const second = assistant("b", "m2", [{ type: "text", text: "second" }]);
+  const events = [sdk(first), result("r1"), sdk(second), result("r2")];
+  const transcript = new Transcript();
+  const before = transcript.update(undefined, events);
+  const after = transcript.update([first, second], events);
+  assert.deepEqual(after.map((item) => item.kind), ["text", "result", "text", "result"]);
+  assert.deepEqual(after.map((item) => item.key), before.map((item) => item.key));
+});
+
+test("history-loaded completed blocks settle every replayed draft instead of leaving thinking cards at the end", () => {
+  const history: SdkMessageLike[] = [];
+  const events: LiveEvent[] = [];
+  for (let index = 0; index < 12; index++) {
+    const id = `m${index}`;
+    const thinking = assistant(`thought${index}`, id, [{ type: "thinking", thinking: `thought ${index}` }]);
+    const text = assistant(`reply${index}`, id, [{ type: "text", text: `reply ${index}` }]);
+    history.push(thinking, text);
+    events.push(delta(id, 0, "thinking", `thought ${index}`), sdk(thinking), delta(id, 1, "text", `reply ${index}`), sdk(text));
+  }
+  const items = buildItems(history, events);
+  assert.equal(items.length, 24);
+  assert.equal(items.filter((item) => item.kind === "thinking").length, 12);
+  assert.equal(items.filter((item) => "streaming" in item && item.streaming).length, 0);
+  assert.deepEqual(items.map((item) => item.kind), Array.from({ length: 12 }, () => ["thinking", "text"]).flat());
+});
+
+test("one completed frame can settle several streamed blocks and late deltas cannot recreate them", () => {
+  const complete = assistant("complete", "m", [{ type: "thinking", thinking: "thought" }, { type: "text", text: "reply" }]);
+  const events = [delta("m", 0, "thinking", "thought"), delta("m", 1, "text", "reply"), sdk(complete), delta("m", 0, "thinking", "late")];
+  assert.deepEqual(buildItems([complete], events).map((item) => item.kind), ["thinking", "text"]);
+});
+
+test("tool completion does not remove a thinking draft belonging to the same API message", () => {
+  const tool = assistant("tool", "m", [{ type: "tool_use", id: "call", name: "Read", input: {} }]);
+  const items = buildItems(undefined, [delta("m", 0, "thinking", "still streaming"), sdk(tool)]);
+  assert.deepEqual(items.map((item) => item.kind), ["tool", "thinking"]);
+  assert.ok("streaming" in items[1]! && items[1].streaming);
+});
+
+test("distinct completed blocks with identical text survive, and a duplicate frame cannot settle the next block", () => {
+  const first = assistant("first", "m", [{ type: "text", text: "Same" }]);
+  const second = assistant("second", "m", [{ type: "text", text: "Same" }]);
+  const transcript = new Transcript();
+  const events = [delta("m", 0, "text", "Same"), sdk(first), delta("m", 1, "text", "Same"), sdk(first)];
+  const pending = transcript.update(undefined, events);
+  assert.equal(pending.length, 2);
+  assert.ok("streaming" in pending[1]! && pending[1].streaming);
+  const completed = transcript.update(undefined, [...events, sdk(second)]);
+  assert.deepEqual(completed.map((item) => item.key), ["first:0", "second:0"]);
+});
+
+test("the same result UUID renders once while distinct results with equal statistics remain separate", () => {
+  assert.equal(buildItems(undefined, [result("r1"), result("r1"), result("r2")]).filter((item) => item.kind === "result").length, 2);
+});
+
+test("a result at the beginning of the replay buffer goes before the next known history message", () => {
+  const first = assistant("a", "m1", [{ type: "text", text: "first" }]);
+  const second = assistant("b", "m2", [{ type: "text", text: "second" }]);
+  assert.deepEqual(buildItems([first, second], [result("r1"), sdk(second), result("r2")]).map((item) => item.kind), ["text", "result", "text", "result"]);
+});
+
+test("hidden subagent frames do not move the main turn's result to the end of history", () => {
+  const first = assistant("a", "m1", [{ type: "text", text: "first" }]);
+  const second = assistant("b", "m2", [{ type: "text", text: "second" }]);
+  const child = assistant("child", "child-api", [{ type: "text", text: "hidden" }], "tool");
+  assert.deepEqual(buildItems([first, second], [sdk(first), sdk(child), result("r1"), sdk(second), result("r2")]).map((item) => item.kind), ["text", "result", "text", "result"]);
+});
+
+test("subagent history overlap settles its own drafts without main-thread interference", () => {
+  const complete = assistant("child", "m", [{ type: "thinking", thinking: "child thought" }]);
+  const events = [delta("m", 0, "thinking", "child thought", "agent"), sdk({ ...complete, parent_tool_use_id: "other" })];
+  const transcript = new Transcript({ parent: "agent" });
+  assert.ok(transcript.update([complete], events).some((item) => "streaming" in item && item.streaming));
+  const own = assistant("own", "m", [{ type: "thinking", thinking: "child thought" }], "agent");
+  const done = transcript.update([complete], [...events, sdk(own)]);
+  assert.equal(done.filter((item) => "streaming" in item && item.streaming).length, 0);
+});
+
+test("multiple runs isolate drafts and settlement even when API message IDs and block indices coincide", () => {
+  const transcript = new Transcript({ parent: "new", parents: new Set(["old", "new"]) });
+  const events: LiveEvent[] = [
+    delta("shared", 0, "thinking", "old thought", "old"),
+    delta("shared", 0, "thinking", "new thought", "new"),
+    delta("shared", 0, "thinking", "sibling thought", "sibling"),
+    delta("shared", 0, "thinking", "main thought"),
+  ];
+  const drafts = transcript.update(undefined, events).filter((item) => item.kind === "thinking");
+  assert.deepEqual(drafts.map((item) => item.text), ["old thought", "new thought"]);
+  assert.notEqual(drafts[0]?.key, drafts[1]?.key);
+  const old = assistant("old-complete", "shared", [{ type: "thinking", thinking: "old thought" }], "old");
+  const afterOld = transcript.update(undefined, [...events, sdk(old)]).filter((item) => item.kind === "thinking");
+  assert.deepEqual(afterOld.map((item) => [item.text, item.streaming]), [["old thought", undefined], ["new thought", true]]);
+  assert.equal(afterOld[0]?.streamStateKey, drafts[0]?.key);
+  const current = assistant("new-complete", "shared", [{ type: "thinking", thinking: "new thought" }], "new");
+  const complete = transcript.update(undefined, [...events, sdk(old), sdk(current), delta("shared", 0, "thinking", "late", "old")]);
+  assert.deepEqual(complete.map((item) => item.key), ["old-complete:0", "new-complete:0"]);
+  assert.equal(complete.filter((item) => item.kind === "thinking")[1]?.streamStateKey, drafts[1]?.key);
+});
+
+test("completed thinking keeps its SDK item key while inheriting its exact stream UI key", () => {
+  const transcript = new Transcript();
+  const events = [delta("api", 0, "thinking", "first"), delta("api", 2, "thinking", "second")];
+  const drafts = transcript.update(undefined, events);
+  const first = assistant("frame-one", "api", [{ type: "thinking", thinking: "first" }]);
+  const second = assistant("frame-two", "api", [{ type: "thinking", thinking: "second" }]);
+  const items = transcript.update(undefined, [...events, sdk(first), sdk(second)]);
+  assert.deepEqual(items.map((item) => item.key), ["frame-one:0", "frame-two:0"]);
+  assert.deepEqual(items.filter((item) => item.kind === "thinking").map((item) => item.streamStateKey), drafts.map((item) => item.key));
+});
+
+test("compacted completions recover thinking fold aliases without replaying discarded deltas", () => {
+  const full = assistant("complete", "api", [
+    { type: "tool_use", id: "read", name: "Read", input: {} },
+    { type: "thinking", thinking: "thought" }, { type: "text", text: "reply" },
+  ]);
+  const event = sdk({ ...full, _streamBlocks: [3, 4] });
+  const items = buildItems([full], [event]);
+  const thinking = items.find((item) => item.kind === "thinking");
+  assert.equal(thinking?.key, "complete:1");
+  assert.equal(thinking?.streamStateKey, "draft-api:3");
+  const partial = buildItems(undefined, [sdk({ ...full, _streamBlocks: [4] })]).find((item) => item.kind === "thinking");
+  assert.equal(partial?.streamStateKey, undefined, "a partial list cannot attribute a text block's index to thinking");
+});
+
+test("a late history anchor preserves the stream alias of an already rendered completed block", () => {
+  const complete = assistant("complete", "api", [{ type: "thinking", thinking: "thought" }]);
+  const transcript = new Transcript();
+  assert.equal(transcript.update([complete], [])[0]?.key, "complete:0");
+  const events = [delta("api", 5, "thinking", "thought"), sdk(complete)];
+  const item = transcript.update([complete], events)[0];
+  assert.equal(item?.kind === "thinking" && item.streamStateKey, "draft-api:5");
+  assert.equal(transcript.update([complete], events).length, 1);
+});
+
+test("live-only internal messages cannot move all statistics to the end of overlapping history", () => {
+  const first = assistant("a", "m1", [{ type: "text", text: "first" }]);
+  const second = assistant("b", "m2", [{ type: "text", text: "second" }]);
+  const hidden: SdkMessageLike = { type: "user", uuid: "meta", message: { content: "<system-reminder>internal</system-reminder>" } };
+  const expected = ["a:0", "result-r1", "b:0", "result-r2"];
+  assert.deepEqual(buildItems([first, second], [sdk(hidden), sdk(first), result("r1"), sdk(second), result("r2")]).map((item) => item.key), expected);
+  assert.deepEqual(buildItems([first, second], [sdk(first), sdk(hidden), result("r1"), sdk(second), result("r2")]).map((item) => item.key), expected);
+});
+
+test("a history anchor arriving in a later batch repositions earlier live-only replay messages", () => {
+  const first = assistant("a", "m1", [{ type: "text", text: "first" }]);
+  const second = assistant("b", "m2", [{ type: "text", text: "second" }]);
+  const hidden: SdkMessageLike = { type: "user", uuid: "meta", message: { content: "<system-reminder>internal</system-reminder>" } };
+  const history = [first, second];
+  const transcript = new Transcript();
+  const events = [sdk(hidden)];
+  transcript.update(history, events);
+  const items = transcript.update(history, [...events, sdk(first), result("r1"), sdk(second), result("r2")]);
+  assert.deepEqual(items.map((item) => item.key), ["a:0", "result-r1", "b:0", "result-r2"]);
+});
+
+test("visible live-only frames retain event order without shifting the preceding result", () => {
+  const first = assistant("a", "m1", [{ type: "text", text: "first" }]);
+  const second = assistant("b", "m2", [{ type: "text", text: "second" }]);
+  const extra = assistant("extra", "transient", [{ type: "text", text: "live-only reply" }]);
+  const events = [sdk(first), result("r1"), sdk(extra), result("extra-result"), sdk(second), result("r2")];
+  const items = buildItems([first, second], events);
+  assert.deepEqual(items.map((item) => item.key), ["a:0", "result-r1", "extra:0", "result-extra-result", "b:0", "result-r2"]);
+});