@linzumi/cli 0.0.5-beta → 0.0.6-beta

package/src/streamDeltaQueue.ts

@@ -0,0 +1,102 @@
+/*
+- Date: 2026-04-26
+  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
+  Relationship: Owns the shared timer/chain lifecycle for runner-batched Codex
+  stream updates so assistant, reasoning, command-output, and file-change
+  deltas all follow one flush state machine.
+*/
+
+export type StreamDeltaQueue<TDelta extends { readonly turnId: string | undefined }> = {
+  pending: TDelta[];
+  timer: ReturnType<typeof setTimeout> | undefined;
+  chain: Promise<void>;
+};
+
+export type StreamDeltaQueueRuntime<TDelta extends { readonly turnId: string | undefined }> = {
+  readonly flushIntervalMs: number;
+  readonly coalesce: (deltas: readonly TDelta[]) => TDelta[];
+  readonly forward: (delta: TDelta) => Promise<void>;
+  readonly firstTurnId: (deltas: readonly TDelta[]) => string | undefined;
+  readonly logFailure: (turnId: string | undefined, error: unknown) => void;
+};
+
+export function createStreamDeltaQueue<
+  TDelta extends { readonly turnId: string | undefined },
+>(): StreamDeltaQueue<TDelta> {
+  return {
+    pending: [],
+    timer: undefined,
+    chain: Promise.resolve(),
+  };
+}
+
+export function enqueueStreamDelta<
+  TDelta extends { readonly turnId: string | undefined },
+>(
+  queue: StreamDeltaQueue<TDelta>,
+  delta: TDelta,
+  runtime: StreamDeltaQueueRuntime<TDelta>,
+): void {
+  queue.pending.push(delta);
+  scheduleStreamDeltaFlush(queue, runtime);
+}
+
+export function flushStreamDeltaQueue<
+  TDelta extends { readonly turnId: string | undefined },
+>(
+  queue: StreamDeltaQueue<TDelta>,
+  runtime: StreamDeltaQueueRuntime<TDelta>,
+): void {
+  clearStreamDeltaFlushTimer(queue);
+
+  const pending = queue.pending;
+
+  if (pending.length === 0) {
+    return;
+  }
+
+  queue.pending = [];
+  const deltas = runtime.coalesce(pending);
+  const previous = queue.chain;
+  const next = previous
+    .catch(() => undefined)
+    .then(async () => {
+      for (const delta of deltas) {
+        await runtime.forward(delta);
+      }
+    });
+
+  queue.chain = next.catch(error => {
+    runtime.logFailure(runtime.firstTurnId(deltas), error);
+  });
+}
+
+export function clearStreamDeltaFlushTimer<
+  TDelta extends { readonly turnId: string | undefined },
+>(queue: StreamDeltaQueue<TDelta>): void {
+  if (queue.timer !== undefined) {
+    clearTimeout(queue.timer);
+    queue.timer = undefined;
+  }
+}
+
+function scheduleStreamDeltaFlush<
+  TDelta extends { readonly turnId: string | undefined },
+>(
+  queue: StreamDeltaQueue<TDelta>,
+  runtime: StreamDeltaQueueRuntime<TDelta>,
+): void {
+  if (queue.timer !== undefined) {
+    return;
+  }
+
+  if (runtime.flushIntervalMs <= 0) {
+    flushStreamDeltaQueue(queue, runtime);
+    return;
+  }
+
+  queue.timer = setTimeout(() => {
+    queue.timer = undefined;
+    flushStreamDeltaQueue(queue, runtime);
+  }, runtime.flushIntervalMs);
+}