@linzumi/cli 0.0.20-beta → 0.0.23-beta

package/src/runnerConsoleReporter.ts

@@ -1,142 +0,0 @@
-/*
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-channel-thread-binding-spec.md
-  Relationship: Provides the headless local-runner stdout status feed required
-  for operators to see accepted, ignored, forwarded, and Codex-output events
-  without printing message bodies or raw Codex payload contents.
-
-- Date: 2026-04-25
-  Spec: plans/2026-04-24-local-codex-runner-deep-quality-spec.md
-  Relationship: Surfaces live reasoning, command-output, and search-progress
-  projection status in headless runner stdout while keeping transcript content
-  out of the console stream.
-*/
-
-type ConsolePayload = Record<string, unknown>;
-
-export function reportRunnerConsoleEvent(event: string, payload: ConsolePayload): void {
-  const line = formatRunnerConsoleEvent(event, payload);
-
-  if (line !== undefined) {
-    process.stdout.write(`${line}\n`);
-  }
-}
-
-export function formatRunnerConsoleEvent(
-  event: string,
-  payload: ConsolePayload,
-): string | undefined {
-  switch (event) {
-    case "runner.instance_started":
-      return `Runner connected: instance=${text(payload.instanceId)} codex=${text(payload.codexUrl)}`;
-
-    case "kandan.message_ignored":
-      return `Incoming message from ${sender(payload)}: ignored for reason ${text(payload.reason)}`;
-
-    case "kandan.message_queued":
-      return `Incoming message from ${sender(payload)}: queued seq=${text(payload.seq)} depth=${text(payload.queue_depth)}`;
-
-    case "kandan.chat_event_failed":
-      return `Incoming message handling failed: seq=${text(payload.seq)} reason=${text(payload.message)}`;
-
-    case "kandan.reconnected":
-      return `Kandan reconnected: codex_session=${text(payload.codex_thread_id)} cursor=${text(payload.min_seq)}`;
-
-    case "codex.turn_starting":
-      return `Incoming message from ${sender(payload)}: forwarding to Codex session ${text(payload.codex_thread_id)} seq=${text(payload.queued_seq)}`;
-
-    case "codex.turn_started":
-      return `Codex turn started: id=${text(payload.turn_id)}`;
-
-    case "codex.notification":
-      return `Codex event [id=${codexEventId(payload)}]: ${text(payload.method)}`;
-
-    case "codex.turn_completed":
-      return `Codex turn completed: id=${text(payload.turn_id)} outputs=${text(payload.output_count)}`;
-
-    case "kandan.codex_output_forwarded":
-      return `Codex event [id=${text(payload.item_key)}]: ${codexOutputLabel(payload)}`;
-
-    case "kandan.codex_reasoning_delta_forwarded":
-      return `Codex event [id=${text(payload.item_key)}]: reasoning_delta chars=${text(payload.content_length)}`;
-
-    case "kandan.codex_command_output_forwarded":
-      return `Codex event [id=${text(payload.item_key)}]: command_output ${text(payload.stream)} chars=${text(payload.output_length)}`;
-
-    case "kandan.codex_web_search_progress_forwarded":
-      return `Codex event [id=${text(payload.item_key)}]: search_progress queries=${text(payload.query_count)}`;
-
-    case "codex.queued_messages_interrupted":
-      return `Queued messages interrupted: selected=${text(payload.selected_count)} remaining=${text(payload.remaining_count)}`;
-
-    case "codex.turn_start_failed":
-      return `Codex turn start failed: seq=${text(payload.queued_seq)} reason=${text(payload.message)}`;
-
-    case "codex.turn_forward_failed":
-      return `Codex turn forward failed: id=${text(payload.turn_id)} reason=${text(payload.message)}`;
-
-    default:
-      return undefined;
-  }
-}
-
-function sender(payload: ConsolePayload): string {
-  const slug = stringValue(payload.actor_slug);
-  const userId = numberValue(payload.actor_user_id);
-
-  if (slug !== undefined && userId !== undefined) {
-    return `${slug}#${userId}`;
-  }
-
-  return slug ?? (userId === undefined ? "unknown" : `user#${userId}`);
-}
-
-function codexOutputLabel(payload: ConsolePayload): string {
-  const kind = stringValue(payload.structured_kind) ?? "output";
-
-  switch (kind) {
-    case "codex_assistant_message":
-      return "assistant_message";
-    case "codex_reasoning":
-      return "reasoning";
-    case "codex_command_execution":
-      return `command ${text(payload.command)}`;
-    case "codex_terminal_input":
-      return "terminal_input";
-    case "codex_file_change":
-      return `file_change ${fileChangePaths(payload)}`;
-    default:
-      return kind;
-  }
-}
-
-function fileChangePaths(payload: ConsolePayload): string {
-  const paths = Array.isArray(payload.file_paths)
-    ? payload.file_paths.filter((value): value is string => typeof value === "string")
-    : [];
-
-  return paths.length === 0 ? "(unknown file)" : paths.slice(0, 3).join(", ");
-}
-
-function codexEventId(payload: ConsolePayload): string {
-  const metadata = payload.metadata;
-
-  if (typeof metadata === "object" && metadata !== null && !Array.isArray(metadata)) {
-    const record = metadata as Record<string, unknown>;
-    return stringValue(record.turnId) ?? stringValue(record.itemId) ?? stringValue(record.threadId) ?? "?";
-  }
-
-  return "?";
-}
-
-function text(value: unknown): string {
-  return stringValue(value) ?? numberValue(value)?.toString() ?? "?";
-}
-
-function stringValue(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() !== "" ? value : undefined;
-}
-
-function numberValue(value: unknown): number | undefined {
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}

package/src/runnerLogger.ts

@@ -1,50 +0,0 @@
-/*
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-channel-thread-binding-spec.md
-  Relationship: Writes the runner's local event log without blocking the
-  websocket/control loop on synchronous filesystem appends.
-*/
-import { openSync } from "node:fs";
-import { createWriteStream, type WriteStream } from "node:fs";
-import { dirname } from "node:path";
-import { mkdirSync } from "node:fs";
-
-export type RunnerConsoleReporter = (event: string, payload: Record<string, unknown>) => void;
-
-export type RunnerLogger = ((event: string, payload: Record<string, unknown>) => void) & {
-  readonly close: () => Promise<void>;
-};
-
-export function createRunnerLogger(
-  logFile: string,
-  consoleReporter?: RunnerConsoleReporter | undefined,
-): RunnerLogger {
-  mkdirSync(dirname(logFile), { recursive: true });
-  const fd = openSync(logFile, "a");
-  const stream = createWriteStream("", { fd, flags: "a", autoClose: true });
-
-  const logger = ((event: string, payload: Record<string, unknown>) => {
-    stream.write(
-      `${JSON.stringify({ ts: new Date().toISOString(), event, ...payload })}\n`,
-      "utf8",
-    );
-    consoleReporter?.(event, payload);
-  }) as RunnerLogger;
-
-  Object.defineProperty(logger, "close", {
-    value: () => closeStream(stream),
-  });
-
-  return logger;
-}
-
-function closeStream(stream: WriteStream): Promise<void> {
-  if (stream.closed || stream.destroyed) {
-    return Promise.resolve();
-  }
-
-  return new Promise((resolve, reject) => {
-    stream.once("error", reject);
-    stream.end(resolve);
-  });
-}

package/src/streamDeltaCoalescing.ts

@@ -1,129 +0,0 @@
-/*
-- Date: 2026-04-26
-  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
-  Relationship: Pure coalescing helpers for runner-batched Codex stream
-  updates, keeping one logical Codex item mapped to one Kandan row while
-  avoiding per-delta state churn in the session orchestrator.
-*/
-import type {
-  CodexAssistantDelta,
-  CodexCommandOutputDelta,
-  CodexFileChangeDelta,
-  CodexReasoningDelta,
-} from "./codexOutput";
-
-type StreamDelta = {
-  readonly itemKey: string;
-  readonly turnId: string | undefined;
-};
-
-type TextDelta = StreamDelta & {
-  readonly delta?: string | undefined;
-  readonly patchText?: string | undefined;
-};
-
-export function coalesceAssistantDeltas(
-  deltas: readonly CodexAssistantDelta[],
-): CodexAssistantDelta[] {
-  return coalesceTextDeltas(deltas, (delta) => ({
-    itemKey: delta.itemKey,
-    turnId: delta.turnId,
-    delta: delta.delta,
-  }));
-}
-
-export function coalesceReasoningDeltas(
-  deltas: readonly CodexReasoningDelta[],
-): CodexReasoningDelta[] {
-  return coalesceTextDeltas(deltas, (delta) => ({
-    itemKey: delta.itemKey,
-    turnId: delta.turnId,
-    delta: delta.delta,
-  }));
-}
-
-export function coalesceFileChangeDeltas(
-  deltas: readonly CodexFileChangeDelta[],
-): CodexFileChangeDelta[] {
-  return coalesceTextDeltas(deltas, (delta) => ({
-    itemKey: delta.itemKey,
-    turnId: delta.turnId,
-    patchText: delta.patchText,
-  }));
-}
-
-export function coalesceCommandOutputDeltas(
-  deltas: readonly CodexCommandOutputDelta[],
-): CodexCommandOutputDelta[] {
-  const coalesced = new Map<string, CodexCommandOutputDelta>();
-
-  for (const delta of deltas) {
-    const key = commandOutputStreamingKey(delta);
-    const existing = coalesced.get(key);
-
-    if (existing === undefined) {
-      coalesced.set(key, delta);
-      continue;
-    }
-
-    coalesced.set(key, {
-      ...delta,
-      processId: delta.processId ?? existing.processId,
-      delta: `${existing.delta}${delta.delta}`,
-    });
-  }
-
-  return [...coalesced.values()];
-}
-
-export function firstDeltaTurnId(
-  deltas: readonly { readonly turnId: string | undefined }[],
-): string | undefined {
-  return deltas.find((delta) => delta.turnId !== undefined)?.turnId;
-}
-
-function coalesceTextDeltas<TDelta extends TextDelta>(
-  deltas: readonly TDelta[],
-  clone: (delta: TDelta) => TDelta,
-): TDelta[] {
-  const coalesced = new Map<string, TDelta>();
-
-  for (const delta of deltas) {
-    const key = streamingItemKey(delta);
-    const existing = coalesced.get(key);
-
-    if (existing === undefined) {
-      coalesced.set(key, clone(delta));
-      continue;
-    }
-
-    coalesced.set(key, mergeTextDelta(existing, delta));
-  }
-
-  return [...coalesced.values()];
-}
-
-function mergeTextDelta<TDelta extends TextDelta>(
-  existing: TDelta,
-  incoming: TDelta,
-): TDelta {
-  if (existing.delta !== undefined || incoming.delta !== undefined) {
-    return {
-      ...incoming,
-      delta: `${existing.delta ?? ""}${incoming.delta ?? ""}`,
-    };
-  }
-
-  return {
-    ...incoming,
-    patchText: `${existing.patchText ?? ""}${incoming.patchText ?? ""}`,
-  };
-}
-
-function streamingItemKey(delta: StreamDelta): string {
-  return `${delta.turnId ?? "turn"}:${delta.itemKey}`;
-}
-
-function commandOutputStreamingKey(delta: CodexCommandOutputDelta): string {
-  return `${streamingItemKey(delta)}:${delta.stream}`;
-}

package/src/streamDeltaQueue.ts

@@ -1,102 +0,0 @@
-/*
-- 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);
-}