@linzumi/cli 1.0.272 → 1.0.274

package/scripts/build-tui-parity-oracle.mjs

@@ -1,577 +0,0 @@
-// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
-// (M3 cluster 11, the TUI).
-// Relationship: Builds the TS-side PARITY ORACLE for the commander
-// console/TUI port - the deterministic core of the console-reporter module
-// (dashboard state fold, selection machinery, key/chunk parsers, every
-// render surface incl. the TUI table/header-layout models) plus the
-// blessed hardening transforms (terminfo conditional repair, the ACS
-// charset fix, the #2955 screen-registry sweep) and the reporter's
-// teardown/degrade/fail-soft latches. ONE bundle imports the REAL TS
-// module exports behind the one-shot batch driver: a JSON array of cases
-// on stdin, a JSON array of results on stdout. The ReScript package's
-// ConsoleTuiParityConformance drives the SAME inputs through
-// src/tui/CommanderConsole* / CommanderTuiGuards and asserts byte-equal
-// rendered strings, deep-equal state projections, and identical event
-// traces.
-//
-// Determinism: every op is pure given its inputs - clocks arrive as
-// explicit nowMs values, and the reporter-latch ops reset the module
-// latches per case via the exported *ForTest hooks. The teardown/degrade
-// ops route observability through explicit sinks (so the TS default audit
-// sink never fires), and scripted dashboards/streams throw
-// deterministically shaped errors.
-//
-// SECRETS: the oracle only ever sees the conformance suite's synthetic
-// payloads; nothing here logs case contents.
-//
-// The output is a local test artifact (.differential/ is gitignored, never
-// published) and stays unminified for debuggability.
-import { mkdir } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { build } from 'esbuild';
-
-const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
-
-const driverSource = `
-import {
-  arrowKeysInRawChunk,
-  createRunnerConsoleDashboard,
-  dashboardJobKeyAtTableRow,
-  dashboardNoticeLines,
-  droppedArrowKeysInRawChunk,
-  formatRunnerConsoleEvent,
-  keypressIsEscape,
-  rawInputChunkContainsMouseReport,
-  rawInputChunkSignalsEscape,
-  renderRunnerConsoleDashboard,
-  resolveSelectionAfterRefresh,
-  runnerConsoleDashboardTableModel,
-  runnerConsoleTuiEscapePressed,
-  runnerConsoleTuiHeaderLayout,
-  selectDashboardJobAtVisibleIndex,
-  selectDashboardJobByKey,
-  tableSelectionPageStep,
-  tableSelectionRowIndex,
-  updateRunnerConsoleDashboard,
-  updateRunnerConsoleDashboardMode,
-  createRunnerConsoleDashboardTuiFailSoft,
-  resetRunnerConsoleDashboardTuiConstructionForTest,
-  teardownRunnerConsoleDashboardTuiSafely,
-  degradeRunnerConsoleTuiToHeadless,
-  resetRunnerConsoleTuiDegradeForTest,
-  runnerConsoleTuiDegradedToHeadless,
-  setRunnerConsoleDashboardTuiForTest,
-  runnerConsoleDashboardTuiActiveForTest,
-} from './src/runnerConsoleReporter';
-import { balanceTerminfoConditionals } from './src/blessedTputSetulcShim';
-import {
-  applyBlessedAcsCharsetFix,
-  blessedWouldUseAcsCharset,
-  forceUnicodeBoxDrawingOnTput,
-} from './src/blessedAcsCharsetShim';
-import {
-  constructBlessedScreenGuarded,
-  detachBlessedScreenFromRegistry,
-  sweepStrandedBlessedScreens,
-} from './src/blessedScreenLifecycleGuard';
-import { linzumiCliVersion } from './src/version';
-
-// --- Projections ------------------------------------------------------------------------
-
-const orNull = (value) => (value === undefined ? null : value);
-
-function projectJob(job) {
-  return {
-    key: job.key,
-    createdAtMs: job.createdAtMs,
-    createdOrdinal: job.createdOrdinal,
-    agentProvider: orNull(job.agentProvider),
-    linzumiThreadId: orNull(job.linzumiThreadId),
-    linzumiThreadTitle: orNull(job.linzumiThreadTitle),
-    // The shared agent-session slot: the TS field carries the deprecated
-    // name; the projection uses the canonical key (D44) so both impls
-    // compare on neutral vocabulary.
-    harnessSessionId: orNull(job.codexThreadId),
-    tokenUsage: orNull(job.tokenUsage),
-    lastIncomingPreview: orNull(job.lastIncomingPreview),
-    lastIncomingAtMs: orNull(job.lastIncomingAtMs),
-    lastAssistantPreview: orNull(job.lastAssistantPreview),
-    lastAssistantAtMs: orNull(job.lastAssistantAtMs),
-    latestHarnessEventId: orNull(job.latestCodexEventId),
-    eventType: orNull(job.eventType),
-    creditExhaustion: orNull(job.creditExhaustion),
-    queueDepth: orNull(job.queueDepth),
-    turnId: orNull(job.turnId),
-    updatedAtMs: job.updatedAtMs,
-  };
-}
-
-function projectState(state) {
-  return {
-    jobs: [...state.jobs.entries()].map(([key, job]) => [key, projectJob(job)]),
-    discovery: [...state.discovery.entries()].map(([key, status]) => [
-      key,
-      {
-        key: status.key,
-        phase: status.phase,
-        status: status.status,
-        placesSearched: status.placesSearched,
-        message: orNull(status.message),
-        currentPlace: orNull(status.currentPlace),
-        currentSource: orNull(status.currentSource),
-        lastError: orNull(status.lastError),
-        metadata: orNull(status.metadata),
-        updatedAtMs: status.updatedAtMs,
-      },
-    ]),
-    notices: [...state.notices.entries()].map(([key, notice]) => [
-      key,
-      {
-        key: notice.key,
-        severity: notice.severity,
-        message: notice.message,
-        count: notice.count,
-        updatedAtMs: notice.updatedAtMs,
-      },
-    ]),
-    rawLines: state.rawLines.map((line) => ({
-      jobKey: orNull(line.jobKey),
-      line: line.line,
-    })),
-    nextJobOrdinal: state.nextJobOrdinal,
-    mode:
-      state.mode.type === 'raw_job'
-        ? { type: 'raw_job', jobKey: state.mode.jobKey }
-        : { type: state.mode.type },
-    selectedJobKey: orNull(state.selectedJobKey),
-    selectedJobIndexHint: orNull(state.selectedJobIndexHint),
-    tokenUsage: orNull(state.tokenUsage),
-    rateLimit: orNull(state.rateLimit),
-    creditExhaustion: orNull(state.creditExhaustion),
-    lastUpdateAtMs: orNull(state.lastUpdateAtMs),
-    browserUrl: orNull(state.browserUrl),
-    workspace: orNull(state.workspace),
-    runnerId: orNull(state.runnerId),
-    connectionStale: state.connectionStale,
-    rosterTruncated: state.rosterTruncated,
-  };
-}
-
-function projectTableModel(model) {
-  return {
-    rows: model.rows,
-    rowJobKeys: model.rowJobKeys.map((key) => orNull(key)),
-    selectedJobKey: orNull(model.selectedJobKey),
-    jobKeys: model.jobs.map((job) => job.key),
-    selectionRowIndex: tableSelectionRowIndex(model),
-  };
-}
-
-// --- scenario: the state fold + render surfaces ------------------------------------------
-
-function handleScenario(testCase) {
-  const state = createRunnerConsoleDashboard();
-  const outputs = [];
-  for (const step of testCase.steps) {
-    switch (step.op) {
-      case 'event':
-        updateRunnerConsoleDashboard(state, step.event, step.payload, step.nowMs);
-        outputs.push(null);
-        break;
-      case 'mode_key':
-        updateRunnerConsoleDashboardMode(state, step.key);
-        outputs.push(null);
-        break;
-      case 'select_index':
-        selectDashboardJobAtVisibleIndex(state, step.index);
-        outputs.push(null);
-        break;
-      case 'select_key':
-        selectDashboardJobByKey(state, step.key ?? undefined);
-        outputs.push(null);
-        break;
-      case 'escape_pressed':
-        outputs.push(runnerConsoleTuiEscapePressed(state));
-        break;
-      case 'escape_chunk': {
-        const signals = rawInputChunkSignalsEscape(step.chunk);
-        const changed = signals ? runnerConsoleTuiEscapePressed(state) : false;
-        outputs.push({ signals, changed });
-        break;
-      }
-      case 'render':
-        outputs.push(orNull(renderRunnerConsoleDashboard(state, step.nowMs)));
-        break;
-      case 'table_model':
-        outputs.push(projectTableModel(runnerConsoleDashboardTableModel(state, step.nowMs)));
-        break;
-      case 'header_layout':
-        outputs.push(
-          runnerConsoleTuiHeaderLayout(
-            state,
-            step.jobCount,
-            step.nowMs,
-            step.terminalRows
-          )
-        );
-        break;
-      case 'notice_lines':
-        outputs.push(dashboardNoticeLines(state, step.mode));
-        break;
-      case 'state':
-        outputs.push(projectState(state));
-        break;
-      default:
-        outputs.push({ threw: true, message: 'unknown scenario step ' + String(step.op) });
-        break;
-    }
-  }
-  return outputs;
-}
-
-// --- Reporter-latch ops -------------------------------------------------------------------
-
-function makeSinkCollector() {
-  const events = [];
-  return {
-    events,
-    sinks: {
-      audit: (event, fields) => events.push({ sink: 'audit', event, fields }),
-      log: (event, fields) => events.push({ sink: 'log', event, fields }),
-    },
-  };
-}
-
-function scriptedError(spec) {
-  const error = new Error(spec.message);
-  if (spec.code !== undefined) {
-    error.code = spec.code;
-  }
-  return error;
-}
-
-function handleTeardownScenario(testCase) {
-  resetRunnerConsoleTuiDegradeForTest();
-  setRunnerConsoleDashboardTuiForTest(undefined);
-  const collector = makeSinkCollector();
-  const outputs = [];
-  let stopCalls = 0;
-  let destroyCalls = 0;
-  for (const step of testCase.steps) {
-    switch (step.op) {
-      case 'install': {
-        destroyCalls = 0;
-        stopCalls = 0;
-        const dashboard = {
-          render: () => {},
-          destroy: () => {
-            destroyCalls += 1;
-            if (step.destroyError !== undefined) {
-              throw scriptedError(step.destroyError);
-            }
-          },
-        };
-        setRunnerConsoleDashboardTuiForTest(
-          dashboard,
-          { stdin: step.stdinTty ?? true, stdout: step.stdoutTty ?? true },
-          () => {
-            stopCalls += 1;
-          }
-        );
-        outputs.push(null);
-        break;
-      }
-      case 'teardown': {
-        const outcome = teardownRunnerConsoleDashboardTuiSafely(
-          { trigger: step.trigger },
-          collector.sinks
-        );
-        outputs.push({
-          hadTui: outcome.hadTui,
-          ok: outcome.ok,
-          swallowedErrorCode: orNull(outcome.swallowedErrorCode),
-          active: runnerConsoleDashboardTuiActiveForTest(),
-          stopCalls,
-          destroyCalls,
-        });
-        break;
-      }
-      case 'degrade': {
-        degradeRunnerConsoleTuiToHeadless(
-          { code: step.code ?? undefined, stage: step.stage },
-          collector.sinks
-        );
-        outputs.push({
-          degraded: runnerConsoleTuiDegradedToHeadless(),
-          active: runnerConsoleDashboardTuiActiveForTest(),
-          stopCalls,
-          destroyCalls,
-        });
-        break;
-      }
-      case 'reset_degrade':
-        resetRunnerConsoleTuiDegradeForTest();
-        outputs.push(null);
-        break;
-      default:
-        outputs.push({ threw: true, message: 'unknown teardown step ' + String(step.op) });
-        break;
-    }
-  }
-  return { outputs, events: collector.events };
-}
-
-function handleFailSoftScenario(testCase) {
-  resetRunnerConsoleDashboardTuiConstructionForTest();
-  const collector = makeSinkCollector();
-  const outputs = [];
-  let createCalls = 0;
-  for (const step of testCase.steps) {
-    switch (step.op) {
-      case 'create': {
-        const result = createRunnerConsoleDashboardTuiFailSoft(() => {
-          createCalls += 1;
-          if (step.createError !== undefined) {
-            throw scriptedError(step.createError);
-          }
-          return { render: () => {}, destroy: () => {} };
-        }, collector.sinks);
-        outputs.push({ defined: result !== undefined, createCalls });
-        break;
-      }
-      case 'reset_construction':
-        resetRunnerConsoleDashboardTuiConstructionForTest();
-        outputs.push(null);
-        break;
-      default:
-        outputs.push({ threw: true, message: 'unknown failsoft step ' + String(step.op) });
-        break;
-    }
-  }
-  return {
-    outputs,
-    // The guarded construction wraps the REAL blessed registry; only the
-    // event vocabulary is compared (stack contents are impl-specific), so
-    // project events to sink+event+swept_screens.
-    events: collector.events.map((entry) => ({
-      sink: entry.sink,
-      event: entry.event,
-      swept_screens: orNull(entry.fields.swept_screens),
-    })),
-  };
-}
-
-// --- Blessed-guard ops -----------------------------------------------------------------------
-
-function makeFakeScreen(spec, sweepTrace) {
-  const screen = {};
-  if (spec.hasProgram) {
-    screen.program = {};
-  }
-  screen.destroy = () => {
-    sweepTrace.push('destroy:' + spec.name);
-    if (spec.destroyError !== undefined) {
-      throw scriptedError(spec.destroyError);
-    }
-    // A real complete screen's destroy() detaches itself from the
-    // registry; the scripted double mirrors that so the sweep's
-    // idempotent re-detach is exercised the same way on both impls.
-    if (spec.selfDetach !== false) {
-      const index = spec.registry.instances.indexOf(screen);
-      if (index !== -1) {
-        spec.registry.instances.splice(index, 1);
-        spec.registry.total -= 1;
-        spec.registry.global = spec.registry.instances[0];
-        if (spec.registry.total === 0) {
-          spec.registry.global = null;
-        }
-      }
-    }
-  };
-  return screen;
-}
-
-function projectRegistry(registry, names) {
-  return {
-    instanceNames: registry.instances.map((instance) => names.get(instance) ?? '?'),
-    total: registry.total,
-    global:
-      registry.global === null
-        ? null
-        : registry.global === undefined
-          ? '<undefined>'
-          : (names.get(registry.global) ?? '?'),
-  };
-}
-
-function handleRegistryGuard(testCase) {
-  const collector = makeSinkCollector();
-  const sweepTrace = [];
-  const registry = { instances: [], total: 0, global: null };
-  const names = new Map();
-  const preexisting = [];
-  for (const spec of testCase.preexisting ?? []) {
-    const screen = makeFakeScreen({ ...spec, registry }, sweepTrace);
-    names.set(screen, spec.name);
-    registry.instances.push(screen);
-    registry.total += 1;
-    preexisting.push(screen);
-  }
-  registry.global = registry.instances[0] ?? null;
-  let result;
-  try {
-    result = {
-      returned: constructBlessedScreenGuarded(
-        registry,
-        () => {
-          for (const spec of testCase.constructed ?? []) {
-            const screen = makeFakeScreen({ ...spec, registry }, sweepTrace);
-            names.set(screen, spec.name);
-            registry.instances.push(screen);
-            registry.total += 1;
-          }
-          if (testCase.constructError !== undefined) {
-            throw scriptedError(testCase.constructError);
-          }
-          return 'constructed';
-        },
-        { sinks: collector.sinks, context: { surface: 'parity_case' } }
-      ),
-    };
-  } catch (error) {
-    result = { threw: true, message: error instanceof Error ? error.message : String(error) };
-  }
-  return {
-    result,
-    registry: projectRegistry(registry, names),
-    sweepTrace,
-    events: collector.events,
-  };
-}
-
-function handleRegistryDetach(testCase) {
-  const registry = { instances: [], total: testCase.total ?? 0, global: null };
-  const names = new Map();
-  const screens = [];
-  for (const name of testCase.instances) {
-    const screen = { name };
-    names.set(screen, name);
-    registry.instances.push(screen);
-    screens.push(screen);
-  }
-  registry.global = registry.instances[0] ?? null;
-  const target = screens[testCase.detachIndex];
-  const detached = detachBlessedScreenFromRegistry(
-    registry,
-    target ?? { name: 'unregistered' }
-  );
-  return { detached, registry: projectRegistry(registry, names) };
-}
-
-// --- Dispatch ----------------------------------------------------------------------------------
-
-function handle(testCase) {
-  switch (testCase.op) {
-    case 'version':
-      return linzumiCliVersion;
-    case 'format_line':
-      return orNull(formatRunnerConsoleEvent(testCase.event, testCase.payload));
-    case 'keys':
-      return {
-        escape: rawInputChunkSignalsEscape(testCase.chunk),
-        mouse: rawInputChunkContainsMouseReport(testCase.chunk),
-        arrows: arrowKeysInRawChunk(testCase.chunk),
-        dropped: droppedArrowKeysInRawChunk(testCase.chunk),
-      };
-    case 'keypress_escape':
-      return keypressIsEscape(testCase.key);
-    case 'selection_resolve': {
-      const resolved = resolveSelectionAfterRefresh(
-        testCase.previousKey ?? undefined,
-        testCase.previousIndexHint ?? undefined,
-        testCase.jobKeys
-      );
-      return { key: orNull(resolved.key), index: orNull(resolved.index) };
-    }
-    case 'page_step':
-      return tableSelectionPageStep(testCase.tableHeight);
-    case 'job_key_at_row': {
-      const state = createRunnerConsoleDashboard();
-      for (const step of testCase.events) {
-        updateRunnerConsoleDashboard(state, step.event, step.payload, step.nowMs);
-      }
-      const model = runnerConsoleDashboardTableModel(state, testCase.nowMs);
-      return testCase.rows.map((row) => orNull(dashboardJobKeyAtTableRow(model, row)));
-    }
-    case 'terminfo_balance':
-      return balanceTerminfoConditionals(testCase.cap);
-    case 'acs_would_use':
-      return blessedWouldUseAcsCharset(
-        testCase.tput ?? undefined,
-        testCase.ch,
-        testCase.alreadyInAcsRun ?? false
-      );
-    case 'acs_force': {
-      const tput = testCase.tput ?? undefined;
-      const mutated = forceUnicodeBoxDrawingOnTput(tput);
-      return { mutated, tput: orNull(tput) };
-    }
-    case 'acs_fix': {
-      const screen = testCase.screen ?? undefined;
-      if (screen !== undefined && testCase.shareProgramTput === true) {
-        screen.program = { tput: screen.tput };
-      }
-      applyBlessedAcsCharsetFix(screen);
-      return orNull(screen);
-    }
-    case 'scenario':
-      return handleScenario(testCase);
-    case 'teardown_scenario':
-      return handleTeardownScenario(testCase);
-    case 'failsoft_scenario':
-      return handleFailSoftScenario(testCase);
-    case 'registry_guard':
-      return handleRegistryGuard(testCase);
-    case 'registry_detach':
-      return handleRegistryDetach(testCase);
-    default:
-      return { threw: true, message: 'unknown op ' + String(testCase.op) };
-  }
-}
-
-let stdin = '';
-process.stdin.setEncoding('utf8');
-for await (const chunk of process.stdin) {
-  stdin += chunk;
-}
-const cases = JSON.parse(stdin);
-const results = [];
-for (const testCase of cases) {
-  results.push(handle(testCase));
-}
-process.stdout.write(JSON.stringify(results));
-`;
-
-await mkdir(join(packageRoot, '.differential'), { recursive: true });
-
-await build({
-  stdin: {
-    contents: driverSource,
-    resolveDir: packageRoot,
-    sourcefile: 'tui-parity-driver.ts',
-    loader: 'ts',
-  },
-  bundle: true,
-  platform: 'node',
-  target: 'node20',
-  format: 'esm',
-  outfile: join(packageRoot, '.differential/tui-parity-oracle.mjs'),
-  minify: false,
-  sourcemap: false,
-  legalComments: 'none',
-  // The console-reporter module imports blessed (and the crash-handler /
-  // logger slice pulls the runtime graph); the runtime externals stay
-  // aligned with the other cluster oracles.
-  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
-});