xonecas.io
64875
Mc

mini-coder / commit 575bfd4

Remove delayed assistant response rendering

xonecas2026-03-08 575bfd4fa19a11de256def4b3c689f41fb907b08 parent 02964eb

2 files changed

src/cli/stream-render.test.ts+105−0
@@ -0,0 +1,105 @@
1+import { afterEach, describe, expect, test } from "bun:test";
2+import type { CoreMessage } from "../llm-api/turn.ts";
3+import type { TurnEvent } from "../llm-api/types.ts";
4+import { Spinner } from "./spinner.ts";
5+import { renderTurn } from "./stream-render.ts";
6+import { terminal } from "./terminal-io.ts";
7+
8+let stdout = "";
9+const originalStdoutWrite = terminal.stdoutWrite.bind(terminal);
10+
11+afterEach(() => {
12+ stdout = "";
13+ terminal.stdoutWrite = originalStdoutWrite;
14+});
15+
16+function captureStdout(): void {
17+ terminal.stdoutWrite = (text: string) => {
18+ stdout += text;
19+ };
20+}
21+
22+function eventsFrom(events: TurnEvent[]): AsyncIterable<TurnEvent> {
23+ return (async function* () {
24+ for (const event of events) {
25+ yield event;
26+ }
27+ })();
28+}
29+
30+function done(messages: CoreMessage[] = []): TurnEvent {
31+ return {
32+ type: "turn-complete",
33+ inputTokens: 1,
34+ outputTokens: 2,
35+ contextTokens: 3,
36+ messages,
37+ };
38+}
39+
40+function strip(s: string): string {
41+ const esc = String.fromCharCode(0x1b);
42+ return s.replace(new RegExp(`${esc}\\[[0-9;]*m`, "g"), "");
43+}
44+
45+function hasAnsi(s: string, code: string): boolean {
46+ return s.includes(`${String.fromCharCode(0x1b)}${code}`);
47+}
48+
49+describe("renderTurn", () => {
50+ test("renders complete lines immediately and flushes the trailing partial line", async () => {
51+ captureStdout();
52+
53+ const result = await renderTurn(
54+ eventsFrom([
55+ { type: "text-delta", delta: "first line\nsecond" },
56+ { type: "text-delta", delta: " line" },
57+ done(),
58+ ]),
59+ new Spinner(),
60+ );
61+
62+ expect(strip(stdout)).toBe("◆ first line\nsecond line\n");
63+ expect(result).toEqual({
64+ inputTokens: 1,
65+ outputTokens: 2,
66+ contextTokens: 3,
67+ newMessages: [],
68+ });
69+ });
70+
71+ test("renders buffered markdown correctly and preserves emoji across deltas", async () => {
72+ captureStdout();
73+
74+ await renderTurn(
75+ eventsFrom([
76+ { type: "text-delta", delta: "**bo" },
77+ { type: "text-delta", delta: "ld** 👩🏽‍💻" },
78+ done(),
79+ ]),
80+ new Spinner(),
81+ );
82+
83+ expect(strip(stdout)).toBe("◆ bold 👩🏽‍💻\n");
84+ expect(hasAnsi(stdout, "[1m")).toBe(true);
85+ });
86+
87+ test("preserves fenced-code state across streamed lines", async () => {
88+ captureStdout();
89+
90+ await renderTurn(
91+ eventsFrom([
92+ { type: "text-delta", delta: "```ts\nconst emoji = '👩🏽‍💻';\n" },
93+ { type: "text-delta", delta: "```\n" },
94+ done(),
95+ ]),
96+ new Spinner(),
97+ );
98+
99+ const lines = stdout.split("\n");
100+ expect(strip(stdout)).toBe("◆ ```ts\nconst emoji = '👩🏽‍💻';\n```\n\n");
101+ expect(hasAnsi(lines[0] ?? "", "[2m")).toBe(true);
102+ expect(hasAnsi(lines[1] ?? "", "[33m")).toBe(true);
103+ expect(hasAnsi(lines[2] ?? "", "[2m")).toBe(true);
104+ });
105+});
src/cli/stream-render.ts+20−60
@@ -3,8 +3,8 @@ import type { CoreMessage } from "../llm-api/turn.ts";
33 import type { TurnEvent } from "../llm-api/types.ts";
44 import { logError } from "./error-log.ts";
55 import { parseAppError } from "./error-parse.ts";
6-import { renderChunk } from "./markdown.ts";
7-import { G, writeln } from "./output.ts";
6+import { renderLine } from "./markdown.ts";
7+import { G, write, writeln } from "./output.ts";
88 import type { Spinner } from "./spinner.ts";
99 import { renderToolCall, renderToolResult } from "./tool-render.ts";
1010
@@ -20,76 +20,36 @@ export async function renderTurn(
2020 let inText = false;
2121 let rawBuffer = "";
2222 let inFence = false;
23- let printQueue = "";
24- let printPos = 0;
25- let tickerHandle: ReturnType<typeof setTimeout> | null = null;
2623
2724 let inputTokens = 0;
2825 let outputTokens = 0;
2926 let contextTokens = 0;
3027 let newMessages: CoreMessage[] = [];
3128
32- function enqueuePrint(ansi: string): void {
33- printQueue += ansi;
34- if (tickerHandle === null) {
35- scheduleTick();
36- }
37- }
38-
39- function tick(): void {
40- tickerHandle = null;
41- if (printPos < printQueue.length) {
42- process.stdout.write(printQueue[printPos] as string);
43- printPos++;
44- scheduleTick();
45- } else {
46- printQueue = "";
47- printPos = 0;
48- }
49- }
50-
51- function scheduleTick(): void {
52- tickerHandle = setTimeout(tick, 8);
53- }
54-
55- function drainQueue(): void {
56- if (tickerHandle !== null) {
57- clearTimeout(tickerHandle);
58- tickerHandle = null;
59- }
60- if (printPos < printQueue.length) {
61- process.stdout.write(printQueue.slice(printPos));
62- }
63- printQueue = "";
64- printPos = 0;
65- }
66-
67- function renderAndTrim(end: number): void {
68- const chunk = rawBuffer.slice(0, end);
69- const rendered = renderChunk(chunk, inFence);
29+ function renderAndWrite(raw: string, endWithNewline: boolean): void {
30+ const rendered = renderLine(raw, inFence);
7031 inFence = rendered.inFence;
71- enqueuePrint(rendered.output);
72- rawBuffer = rawBuffer.slice(end);
32+ write(rendered.output);
33+ if (endWithNewline) {
34+ write("\n");
35+ }
7336 }
7437
75- function flushChunks(): void {
76- let boundary = rawBuffer.indexOf("\n\n");
77- if (boundary !== -1) {
78- renderAndTrim(boundary + 2);
79- flushChunks();
80- return;
81- }
82- boundary = rawBuffer.lastIndexOf("\n");
83- if (boundary !== -1) {
84- renderAndTrim(boundary + 1);
38+ function flushCompleteLines(): void {
39+ let boundary = rawBuffer.indexOf("\n");
40+ while (boundary !== -1) {
41+ renderAndWrite(rawBuffer.slice(0, boundary), true);
42+ rawBuffer = rawBuffer.slice(boundary + 1);
43+ boundary = rawBuffer.indexOf("\n");
8544 }
8645 }
8746
8847 function flushAll(): void {
89- if (rawBuffer) {
90- renderAndTrim(rawBuffer.length);
48+ if (!rawBuffer) {
49+ return;
9150 }
92- drainQueue();
51+ renderAndWrite(rawBuffer, false);
52+ rawBuffer = "";
9353 }
9454
9555 for await (const event of events) {
@@ -97,11 +57,11 @@ export async function renderTurn(
9757 case "text-delta": {
9858 if (!inText) {
9959 spinner.stop();
100- process.stdout.write(`${G.reply} `);
60+ write(`${G.reply} `);
10161 inText = true;
10262 }
10363 rawBuffer += event.delta;
104- flushChunks();
64+ flushCompleteLines();
10565 break;
10666 }