mimo-reasonix 0.1.0 → 0.1.1

package/node_modules/ink/src/terminal-focus-state.ts

@@ -0,0 +1,46 @@
+/** Tri-state focus tracking driven by DECSET 1004 (xterm focus reporting). */
+export type TerminalFocusState = 'focused' | 'blurred' | 'unknown';
+
+let focusState: TerminalFocusState = 'unknown';
+const subscribers: Set<() => void> = new Set();
+const blurResolvers: Set<() => void> = new Set();
+
+/** Apply a focus-reporting update from the terminal stream. */
+export function setTerminalFocused(focused: boolean): void {
+  focusState = focused ? 'focused' : 'blurred';
+
+  for (const notify of subscribers) {
+    notify();
+  }
+
+  if (!focused) {
+    for (const resolve of blurResolvers) {
+      resolve();
+    }
+    blurResolvers.clear();
+  }
+}
+
+export function getTerminalFocused(): boolean {
+  return focusState !== 'blurred';
+}
+
+export function getTerminalFocusState(): TerminalFocusState {
+  return focusState;
+}
+
+/** `useSyncExternalStore` `subscribe` argument. */
+export function subscribeTerminalFocus(notify: () => void): () => void {
+  subscribers.add(notify);
+  return () => {
+    subscribers.delete(notify);
+  };
+}
+
+/** Reset focus state to `unknown`. */
+export function resetTerminalFocusState(): void {
+  focusState = 'unknown';
+  for (const notify of subscribers) {
+    notify();
+  }
+}

package/node_modules/ink/src/terminal-querier.ts

@@ -0,0 +1,143 @@
+/** Send queries to the terminal and resolve replies without per-query timeouts. */
+
+import type { TerminalResponse } from './parse-keypress.js';
+import { csi } from './termio/csi.js';
+import { osc } from './termio/osc.js';
+
+export type TerminalQuery<T extends TerminalResponse = TerminalResponse> = {
+  /** Sequence to write to stdout. */
+  request: string;
+  /** Returns true when `r` is this query's reply. */
+  match: (r: TerminalResponse) => r is T;
+};
+
+type DecrpmResponse = Extract<TerminalResponse, { type: 'decrpm' }>;
+type Da1Response = Extract<TerminalResponse, { type: 'da1' }>;
+type Da2Response = Extract<TerminalResponse, { type: 'da2' }>;
+type KittyResponse = Extract<TerminalResponse, { type: 'kittyKeyboard' }>;
+type CursorPosResponse = Extract<TerminalResponse, { type: 'cursorPosition' }>;
+type OscResponse = Extract<TerminalResponse, { type: 'osc' }>;
+type XtversionResponse = Extract<TerminalResponse, { type: 'xtversion' }>;
+
+// --- Query builders -------------------------------------------------------
+
+/** DECRQM — request DEC private mode status (CSI ? mode $ p). */
+export function decrqm(mode: number): TerminalQuery<DecrpmResponse> {
+  return {
+    request: csi(`?${mode}$p`),
+    match: (r): r is DecrpmResponse => r.type === 'decrpm' && r.mode === mode,
+  };
+}
+
+/** DA1 — Primary Device Attributes (CSI c). */
+export function da1(): TerminalQuery<Da1Response> {
+  return {
+    request: csi('c'),
+    match: (r): r is Da1Response => r.type === 'da1',
+  };
+}
+
+/** DA2 — Secondary Device Attributes (CSI > c). Returns terminal version. */
+export function da2(): TerminalQuery<Da2Response> {
+  return {
+    request: csi('>c'),
+    match: (r): r is Da2Response => r.type === 'da2',
+  };
+}
+
+/** Query the current Kitty keyboard protocol flags (CSI ? u). */
+export function kittyKeyboard(): TerminalQuery<KittyResponse> {
+  return {
+    request: csi('?u'),
+    match: (r): r is KittyResponse => r.type === 'kittyKeyboard',
+  };
+}
+
+/** DECXCPR — cursor position with the DEC-private marker (CSI ? 6 n). */
+export function cursorPosition(): TerminalQuery<CursorPosResponse> {
+  return {
+    request: csi('?6n'),
+    match: (r): r is CursorPosResponse => r.type === 'cursorPosition',
+  };
+}
+
+export function oscColor(code: number): TerminalQuery<OscResponse> {
+  return {
+    request: osc(code, '?'),
+    match: (r): r is OscResponse => r.type === 'osc' && r.code === code,
+  };
+}
+
+/** XTVERSION — terminal name + version (CSI > 0 q). */
+export function xtversion(): TerminalQuery<XtversionResponse> {
+  return {
+    request: csi('>0q'),
+    match: (r): r is XtversionResponse => r.type === 'xtversion',
+  };
+}
+
+// --- Querier --------------------------------------------------------------
+
+/** Internal DA1 byte sequence used by `flush()` as a universal barrier. */
+const SENTINEL = csi('c');
+
+type PendingQuery = {
+  kind: 'query';
+  match: (r: TerminalResponse) => boolean;
+  resolve: (r: TerminalResponse | undefined) => void;
+};
+
+type PendingSentinel = {
+  kind: 'sentinel';
+  resolve: () => void;
+};
+
+type Pending = PendingQuery | PendingSentinel;
+
+export class TerminalQuerier {
+  /** Interleaved queue of queries and sentinels in send order. */
+  private queue: Pending[] = [];
+
+  constructor(private stdout: NodeJS.WriteStream) {}
+
+  /** Write a query to stdout and wait for its reply. */
+  send<T extends TerminalResponse>(
+    query: TerminalQuery<T>,
+  ): Promise<T | undefined> {
+    return new Promise(resolve => {
+      this.queue.push({
+        kind: 'query',
+        match: query.match,
+        resolve: r => resolve(r as T | undefined),
+      });
+      this.stdout.write(query.request);
+    });
+  }
+
+  /** Write the DA1 sentinel and wait for its reply. */
+  flush(): Promise<void> {
+    return new Promise(resolve => {
+      this.queue.push({ kind: 'sentinel', resolve });
+      this.stdout.write(SENTINEL);
+    });
+  }
+
+  /** Hand a parsed terminal response to the querier. */
+  onResponse(r: TerminalResponse): void {
+    const idx = this.queue.findIndex(p => p.kind === 'query' && p.match(r));
+    if (idx !== -1) {
+      const [q] = this.queue.splice(idx, 1);
+      if (q?.kind === 'query') q.resolve(r);
+      return;
+    }
+
+    if (r.type === 'da1') {
+      const s = this.queue.findIndex(p => p.kind === 'sentinel');
+      if (s === -1) return;
+      for (const p of this.queue.splice(0, s + 1)) {
+        if (p.kind === 'query') p.resolve(undefined);
+        else p.resolve();
+      }
+    }
+  }
+}

package/node_modules/ink/src/terminal.ts

@@ -0,0 +1,220 @@
+import { coerce } from 'semver';
+import type { Writable } from 'stream';
+import { env } from './_internal/env.js';
+import { gte } from './_internal/semver.js';
+import { getClearTerminalSequence } from './clearTerminal.js';
+import type { Diff } from './frame.js';
+import { cursorMove, cursorTo, eraseLines } from './termio/csi.js';
+import { BSU, ESU, HIDE_CURSOR, SHOW_CURSOR } from './termio/dec.js';
+import { link } from './termio/osc.js';
+
+export type Progress = {
+  state: 'running' | 'completed' | 'error' | 'indeterminate';
+  percentage?: number;
+};
+
+/** Whether the host terminal interprets OSC 9;4 as a progress indicator. */
+export function isProgressReportingAvailable(): boolean {
+  if (!process.stdout.isTTY) {
+    return false;
+  }
+
+  // Windows Terminal hijacks OSC 9;4 for notifications — sending progress
+  // there is actively user-hostile.
+  if (process.env.WT_SESSION) {
+    return false;
+  }
+
+  if (
+    process.env.ConEmuANSI ||
+    process.env.ConEmuPID ||
+    process.env.ConEmuTask
+  ) {
+    return true;
+  }
+
+  const version = coerce(process.env.TERM_PROGRAM_VERSION);
+  if (!version) {
+    return false;
+  }
+
+  if (process.env.TERM_PROGRAM === 'ghostty') {
+    return gte(version.version, '1.2.0');
+  }
+
+  if (process.env.TERM_PROGRAM === 'iTerm.app') {
+    return gte(version.version, '3.6.6');
+  }
+
+  return false;
+}
+
+/** Whether DEC mode 2026 (synchronized output) is honoured end-to-end. */
+export function isSynchronizedOutputSupported(): boolean {
+  // tmux parses every byte but doesn't preserve atomicity — the BSU/ESU
+  // pair passes through to the outer terminal, but tmux has already broken
+  // up the frame on its own buffer boundaries. Skip the 16 bytes/frame +
+  // parser work since they buy nothing.
+  if (process.env.TMUX) return false;
+
+  const termProgram = process.env.TERM_PROGRAM;
+  const term = process.env.TERM;
+
+  if (
+    termProgram === 'iTerm.app' ||
+    termProgram === 'WezTerm' ||
+    termProgram === 'WarpTerminal' ||
+    termProgram === 'ghostty' ||
+    termProgram === 'contour' ||
+    termProgram === 'vscode' ||
+    termProgram === 'alacritty'
+  ) {
+    return true;
+  }
+
+  // kitty advertises itself through TERM or its session env var.
+  if (term?.includes('kitty') || process.env.KITTY_WINDOW_ID) return true;
+
+  // Ghostty sometimes sets TERM without TERM_PROGRAM (e.g. over SSH).
+  if (term === 'xterm-ghostty') return true;
+
+  // foot ships under TERM=foot or foot-extra.
+  if (term?.startsWith('foot')) return true;
+
+  if (term?.includes('alacritty')) return true;
+
+  // Zed embeds alacritty_terminal, which implements DEC 2026.
+  if (process.env.ZED_TERM) return true;
+
+  if (process.env.WT_SESSION) return true;
+
+  // VTE-based terminals (GNOME Terminal, Tilix, Terminator, ...) gained
+  // DEC 2026 support in VTE 0.68. VTE_VERSION is exposed as YYMMDD-style
+  // integer with 6800 == 0.68.00.
+  const vteVersion = process.env.VTE_VERSION;
+  if (vteVersion) {
+    const version = parseInt(vteVersion, 10);
+    if (version >= 6800) return true;
+  }
+
+  return false;
+}
+
+// --- XTVERSION-based terminal identification ------------------------------
+//
+// TERM_PROGRAM doesn't survive SSH, so env-based detection misses the case
+// where we're running remotely inside (say) a VS Code integrated terminal.
+// XTVERSION (CSI > 0 q -> DCS > | <name> ST) is asked through the pty, so
+// the reply identifies the *client* terminal regardless of how the
+// environment was forwarded. The reply is delivered asynchronously through
+// stdin and parsed by the input pipeline, which feeds the name in here.
+
+let xtversionName: string | undefined;
+
+/** Record the name reported by an XTVERSION reply. */
+export function setXtversionName(name: string): void {
+  if (xtversionName === undefined) xtversionName = name;
+}
+
+/** Whether the terminal in front of the user is an xterm.js embedder. */
+export function isXtermJs(): boolean {
+  if (process.env.TERM_PROGRAM === 'vscode') return true;
+  return xtversionName?.startsWith('xterm.js') ?? false;
+}
+
+// Terminals known to implement the Kitty keyboard protocol (CSI >1u) or
+// xterm modifyOtherKeys (CSI >4;2m) correctly. The naive approach is to
+// enable extended key reporting unconditionally and rely on terminals
+// ignoring unknown CSI sequences — that breaks when a terminal *accepts*
+// the enable but emits codepoints we can't decode, which we've observed
+// over SSH and inside xterm.js. tmux is on the list because it accepts
+// modifyOtherKeys at its layer without forwarding the kitty sequence to
+// the outer terminal.
+//
+// Stored as a Set so the per-call membership test is O(1); the previous
+// Array.includes() walk was negligible for one call per process, but the
+// shape change costs nothing and is the more honest spelling of "set
+// membership".
+const EXTENDED_KEYS_TERMINALS = new Set<string>([
+  'iTerm.app',
+  'kitty',
+  'WezTerm',
+  'ghostty',
+  'tmux',
+  'windows-terminal',
+]);
+
+/** Whether to opt in to extended-key reporting (Kitty + modifyOtherKeys). */
+export function supportsExtendedKeys(): boolean {
+  return EXTENDED_KEYS_TERMINALS.has(env.terminal ?? '');
+}
+
+export function hasCursorUpViewportYankBug(): boolean {
+  return process.platform === 'win32' || !!process.env.WT_SESSION;
+}
+
+// Snapshot once at module load — terminal capabilities don't change
+// mid-session, and the synchronized-output decision is consulted on every
+// frame. Re-exported so log-update can take the fast path when sync output
+// is unavailable.
+export const SYNC_OUTPUT_SUPPORTED = isSynchronizedOutputSupported();
+
+export type Terminal = {
+  stdout: Writable;
+  stderr: Writable;
+};
+
+/** Serialise a Diff into bytes and ship it to the terminal. */
+export function writeDiffToTerminal(
+  terminal: Terminal,
+  diff: Diff,
+  skipSyncMarkers = false,
+): void {
+  if (diff.length === 0) {
+    return;
+  }
+
+  const useSync = !skipSyncMarkers;
+
+  let buffer = useSync ? BSU : '';
+
+  for (const patch of diff) {
+    switch (patch.type) {
+      case 'stdout':
+        buffer += patch.content;
+        break;
+      case 'clear':
+        if (patch.count > 0) {
+          buffer += eraseLines(patch.count);
+        }
+        break;
+      case 'clearTerminal':
+        buffer += getClearTerminalSequence();
+        break;
+      case 'cursorHide':
+        buffer += HIDE_CURSOR;
+        break;
+      case 'cursorShow':
+        buffer += SHOW_CURSOR;
+        break;
+      case 'cursorMove':
+        buffer += cursorMove(patch.x, patch.y);
+        break;
+      case 'cursorTo':
+        buffer += cursorTo(patch.col);
+        break;
+      case 'carriageReturn':
+        buffer += '\r';
+        break;
+      case 'hyperlink':
+        buffer += link(patch.uri);
+        break;
+      case 'styleStr':
+        buffer += patch.str;
+        break;
+    }
+  }
+
+  if (useSync) buffer += ESU;
+  terminal.stdout.write(buffer);
+}

package/node_modules/ink/src/termio/ansi.ts

@@ -0,0 +1,66 @@
+/** Low-level constants for the ECMA-48 / ANSI X3.64 byte alphabet. */
+
+/** C0 control characters (bytes 0x00–0x1F plus DEL 0x7F). */
+export const C0 = {
+  NUL: 0x00,
+  SOH: 0x01,
+  STX: 0x02,
+  ETX: 0x03,
+  EOT: 0x04,
+  ENQ: 0x05,
+  ACK: 0x06,
+  BEL: 0x07,
+  BS: 0x08,
+  HT: 0x09,
+  LF: 0x0a,
+  VT: 0x0b,
+  FF: 0x0c,
+  CR: 0x0d,
+  SO: 0x0e,
+  SI: 0x0f,
+  DLE: 0x10,
+  DC1: 0x11,
+  DC2: 0x12,
+  DC3: 0x13,
+  DC4: 0x14,
+  NAK: 0x15,
+  SYN: 0x16,
+  ETB: 0x17,
+  CAN: 0x18,
+  EM: 0x19,
+  SUB: 0x1a,
+  ESC: 0x1b,
+  FS: 0x1c,
+  GS: 0x1d,
+  RS: 0x1e,
+  US: 0x1f,
+  DEL: 0x7f,
+} as const
+
+// String forms of the bytes we splice into output sequences. Keeping them
+// here (rather than letting each generator do `String.fromCharCode`) makes
+// the generated sequences trivially greppable.
+export const ESC = '\x1b'
+export const BEL = '\x07'
+export const SEP = ';'
+
+/** Bytes that may follow ESC to introduce a longer sequence. */
+export const ESC_TYPE = {
+  CSI: 0x5b, // [ — Control Sequence Introducer
+  OSC: 0x5d, // ] — Operating System Command
+  DCS: 0x50, // P — Device Control String
+  APC: 0x5f, // _ — Application Program Command
+  PM: 0x5e, // ^ — Privacy Message
+  SOS: 0x58, // X — Start of String
+  ST: 0x5c, // \ — String Terminator
+} as const
+
+/** True for any C0 control byte (0x00–0x1F) or DEL (0x7F). */
+export function isC0(byte: number): boolean {
+  return byte < 0x20 || byte === 0x7f
+}
+
+/** Final-byte test for two-character ESC sequences (ESC + one printable). */
+export function isEscFinal(byte: number): boolean {
+  return byte >= 0x30 && byte <= 0x7e
+}