mimo-reasonix 0.1.0 → 0.1.1

package/node_modules/ink/src/Ansi.tsx

@@ -0,0 +1,254 @@
+import React from 'react';
+import Link from './components/Link.js';
+import Text from './components/Text.js';
+import type { Color } from './styles.js';
+import {
+  type NamedColor,
+  Parser,
+  type Color as TermioColor,
+  type TextStyle,
+} from './termio.js';
+
+type Props = {
+  children: string;
+  /** When true, force all text to be rendered with dim styling. */
+  dimColor?: boolean;
+};
+
+type SpanProps = {
+  color?: Color;
+  backgroundColor?: Color;
+  dim?: boolean;
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  strikethrough?: boolean;
+  inverse?: boolean;
+  hyperlink?: string;
+};
+
+type Span = {
+  text: string;
+  props: SpanProps;
+};
+
+export const Ansi = React.memo(function Ansi({ children, dimColor }: Props) {
+  if (typeof children !== 'string') {
+    return dimColor ? <Text dim>{String(children)}</Text> : <Text>{String(children)}</Text>;
+  }
+
+  if (children === '') return null;
+
+  const spans = parseToSpans(children);
+  if (spans.length === 0) return null;
+
+  // Single-span fast path: skip the array map and avoid the wrapper
+  // <Text> when the only span has no styling of its own.
+  if (spans.length === 1 && !hasAnyProps(spans[0]!.props)) {
+    return dimColor ? <Text dim>{spans[0]!.text}</Text> : <Text>{spans[0]!.text}</Text>;
+  }
+
+  const content = spans.map((span, i) => {
+    const hyperlink = span.props.hyperlink;
+    if (dimColor) span.props.dim = true;
+    const hasTextProps = hasAnyTextProps(span.props);
+
+    if (hyperlink) {
+      return hasTextProps ? (
+        <Link key={i} url={hyperlink}>
+          <StyledText
+            color={span.props.color}
+            backgroundColor={span.props.backgroundColor}
+            dim={span.props.dim}
+            bold={span.props.bold}
+            italic={span.props.italic}
+            underline={span.props.underline}
+            strikethrough={span.props.strikethrough}
+            inverse={span.props.inverse}
+          >
+            {span.text}
+          </StyledText>
+        </Link>
+      ) : (
+        <Link key={i} url={hyperlink}>
+          {span.text}
+        </Link>
+      );
+    }
+
+    return hasTextProps ? (
+      <StyledText
+        key={i}
+        color={span.props.color}
+        backgroundColor={span.props.backgroundColor}
+        dim={span.props.dim}
+        bold={span.props.bold}
+        italic={span.props.italic}
+        underline={span.props.underline}
+        strikethrough={span.props.strikethrough}
+        inverse={span.props.inverse}
+      >
+        {span.text}
+      </StyledText>
+    ) : (
+      span.text
+    );
+  });
+
+  return dimColor ? <Text dim>{content}</Text> : <Text>{content}</Text>;
+});
+
+function parseToSpans(input: string): Span[] {
+  const parser = new Parser();
+  const actions = parser.feed(input);
+  const spans: Span[] = [];
+  let currentHyperlink: string | undefined;
+
+  for (const action of actions) {
+    if (action.type === 'link') {
+      currentHyperlink = action.action.type === 'start' ? action.action.url : undefined;
+      continue;
+    }
+
+    if (action.type === 'text') {
+      const text = action.graphemes.map((g) => g.value).join('');
+      if (!text) continue;
+
+      const props = textStyleToSpanProps(action.style);
+      if (currentHyperlink) props.hyperlink = currentHyperlink;
+
+      const lastSpan = spans[spans.length - 1];
+      if (lastSpan && propsEqual(lastSpan.props, props)) {
+        lastSpan.text += text;
+      } else {
+        spans.push({ text, props });
+      }
+    }
+  }
+
+  return spans;
+}
+
+function textStyleToSpanProps(style: TextStyle): SpanProps {
+  const props: SpanProps = {};
+  if (style.bold) props.bold = true;
+  if (style.dim) props.dim = true;
+  if (style.italic) props.italic = true;
+  if (style.underline !== 'none') props.underline = true;
+  if (style.strikethrough) props.strikethrough = true;
+  if (style.inverse) props.inverse = true;
+
+  const fg = colorToString(style.fg);
+  if (fg) props.color = fg;
+  const bg = colorToString(style.bg);
+  if (bg) props.backgroundColor = bg;
+
+  return props;
+}
+
+/** Map termio's named-colour identifiers to the `ansi:*` form Ink uses. */
+const NAMED_COLOR_MAP: Record<NamedColor, string> = {
+  black: 'ansi:black',
+  red: 'ansi:red',
+  green: 'ansi:green',
+  yellow: 'ansi:yellow',
+  blue: 'ansi:blue',
+  magenta: 'ansi:magenta',
+  cyan: 'ansi:cyan',
+  white: 'ansi:white',
+  brightBlack: 'ansi:blackBright',
+  brightRed: 'ansi:redBright',
+  brightGreen: 'ansi:greenBright',
+  brightYellow: 'ansi:yellowBright',
+  brightBlue: 'ansi:blueBright',
+  brightMagenta: 'ansi:magentaBright',
+  brightCyan: 'ansi:cyanBright',
+  brightWhite: 'ansi:whiteBright',
+};
+
+function colorToString(color: TermioColor): Color | undefined {
+  switch (color.type) {
+    case 'named':
+      return NAMED_COLOR_MAP[color.name] as Color;
+    case 'indexed':
+      return `ansi256(${color.index})` as Color;
+    case 'rgb':
+      return `rgb(${color.r},${color.g},${color.b})` as Color;
+    case 'default':
+      return undefined;
+  }
+}
+
+function propsEqual(a: SpanProps, b: SpanProps): boolean {
+  return (
+    a.color === b.color &&
+    a.backgroundColor === b.backgroundColor &&
+    a.bold === b.bold &&
+    a.dim === b.dim &&
+    a.italic === b.italic &&
+    a.underline === b.underline &&
+    a.strikethrough === b.strikethrough &&
+    a.inverse === b.inverse &&
+    a.hyperlink === b.hyperlink
+  );
+}
+
+function hasAnyProps(props: SpanProps): boolean {
+  return (
+    props.color !== undefined ||
+    props.backgroundColor !== undefined ||
+    props.dim === true ||
+    props.bold === true ||
+    props.italic === true ||
+    props.underline === true ||
+    props.strikethrough === true ||
+    props.inverse === true ||
+    props.hyperlink !== undefined
+  );
+}
+
+function hasAnyTextProps(props: SpanProps): boolean {
+  return (
+    props.color !== undefined ||
+    props.backgroundColor !== undefined ||
+    props.dim === true ||
+    props.bold === true ||
+    props.italic === true ||
+    props.underline === true ||
+    props.strikethrough === true ||
+    props.inverse === true
+  );
+}
+
+type BaseTextStyleProps = {
+  color?: Color;
+  backgroundColor?: Color;
+  italic?: boolean;
+  underline?: boolean;
+  strikethrough?: boolean;
+  inverse?: boolean;
+};
+
+type StyledTextProps = BaseTextStyleProps & {
+  bold?: boolean;
+  dim?: boolean;
+  children: React.ReactNode;
+};
+
+function StyledText({ bold, dim, children, ...rest }: StyledTextProps) {
+  if (dim) {
+    return (
+      <Text {...rest} dim>
+        {children}
+      </Text>
+    );
+  }
+  if (bold) {
+    return (
+      <Text {...rest} bold>
+        {children}
+      </Text>
+    );
+  }
+  return <Text {...rest}>{children}</Text>;
+}

package/node_modules/ink/src/_internal/debug.ts

@@ -0,0 +1,27 @@
+import { isEnvTruthy } from './envUtils.js';
+
+type DebugOptions = {
+  reentrant?: boolean;
+  level?: string | number;
+};
+
+// Off by default. The env var lets us trace renderer activity in production
+// builds without recompiling — useful when a downstream consumer hits a
+// terminal-specific glitch we cannot reproduce locally.
+let debugEnabled = isEnvTruthy(process.env['REASONIX_DEBUG_INK']);
+
+export function setDebugLogging(enabled: boolean): void {
+  debugEnabled = enabled;
+}
+
+export function logForDebugging(message: string, _opts?: DebugOptions): void {
+  if (!debugEnabled) return;
+  // stderr can throw EPIPE when the receiving end has gone away (e.g. the
+  // process is being torn down). Diagnostics must never crash the host app,
+  // so we swallow — there is nowhere else to report this anyway.
+  try {
+    process.stderr.write(`[ink·debug] ${message}\n`);
+  } catch {
+    /* stderr unavailable during shutdown */
+  }
+}

package/node_modules/ink/src/_internal/earlyInput.ts

@@ -0,0 +1,7 @@
+// Placeholder hook for a future "capture stdin before React mounts" feature.
+// Some host CLIs need to buffer keystrokes typed during boot so they aren't
+// dropped before the input reader is wired up. We keep the export so call
+// sites compile, but right now there is nothing to stop.
+export function stopCapturingEarlyInput(): void {
+  /* intentionally empty until early-input buffering is implemented */
+}

package/node_modules/ink/src/_internal/env.ts

@@ -0,0 +1,38 @@
+// Terminal identification is needed to gate features (OSC 8 hyperlinks,
+// Kitty keyboard protocol, sixel graphics, etc.). Detection runs once at
+// module load: the host terminal does not change mid-process, and a static
+// snapshot keeps every call site cheap.
+
+type TerminalKind =
+  | 'kitty'
+  | 'iterm'
+  | 'wezterm'
+  | 'vscode'
+  | 'tmux'
+  | 'ghostty'
+  | 'windows-terminal'
+  | '';
+
+function detectTerminal(): TerminalKind {
+  const termProgram = process.env['TERM_PROGRAM'] ?? '';
+  if (termProgram === 'iTerm.app') return 'iterm';
+  if (termProgram === 'vscode') return 'vscode';
+  if (termProgram === 'WezTerm') return 'wezterm';
+  if (termProgram === 'ghostty') return 'ghostty';
+
+  // Kitty doesn't set TERM_PROGRAM, but always sets either KITTY_WINDOW_ID
+  // or a TERM containing "kitty" (e.g. xterm-kitty).
+  if (process.env['KITTY_WINDOW_ID'] || process.env['TERM']?.includes('kitty')) {
+    return 'kitty';
+  }
+
+  // Windows Terminal exposes WT_SESSION. Check before tmux because tmux can
+  // legitimately run inside Windows Terminal and we want the outer host.
+  if (process.env['WT_SESSION']) return 'windows-terminal';
+  if (process.env['TMUX']) return 'tmux';
+  return '';
+}
+
+export const env = {
+  terminal: detectTerminal(),
+} as const;

package/node_modules/ink/src/_internal/envUtils.ts

@@ -0,0 +1,13 @@
+// Env vars are strings or undefined. Accept the common truthy spellings users
+// reach for instinctively — "1", "true", "yes", "on" — so feature flags work
+// regardless of which convention the caller picked up from another tool.
+export function isEnvTruthy(value: string | undefined | null): boolean {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return (
+    normalized === '1' ||
+    normalized === 'true' ||
+    normalized === 'yes' ||
+    normalized === 'on'
+  );
+}

package/node_modules/ink/src/_internal/execFileNoThrow.ts

@@ -0,0 +1,58 @@
+import { execFile } from 'node:child_process';
+
+type ExecResult = {
+  code: number;
+  stdout: string;
+  stderr: string;
+};
+
+type ExecOpts = {
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  timeout?: number;
+  signal?: AbortSignal;
+  input?: string;
+};
+
+// Variant of `execFile` that never rejects. Callers (mainly OSC integrations
+// probing optional terminal helpers) treat a non-zero exit code as data, not
+// an exceptional condition — turning each invocation into a try/catch would
+// be noise. The 10 MiB buffer matches Node's default ceiling shape; anything
+// larger from a terminal helper would already indicate something is wrong.
+export function execFileNoThrow(
+  file: string,
+  args: readonly string[],
+  opts: ExecOpts = {},
+): Promise<ExecResult> {
+  return new Promise((resolve) => {
+    const child = execFile(
+      file,
+      args as string[],
+      {
+        cwd: opts.cwd,
+        env: opts.env ?? process.env,
+        timeout: opts.timeout,
+        signal: opts.signal,
+        encoding: 'utf8',
+        maxBuffer: 10 * 1024 * 1024,
+      },
+      (err, stdout, stderr) => {
+        // Node attaches a numeric exit code on ExecException for normal
+        // non-zero exits, and a string code (e.g. 'ENOENT') for spawn
+        // failures. We only forward numeric codes; anything else collapses
+        // to a generic failure (1) so callers see a uniform shape.
+        const errnoCode = (err as NodeJS.ErrnoException | null)?.code;
+        const code =
+          typeof errnoCode === 'number' ? errnoCode : err ? 1 : 0;
+        resolve({
+          code,
+          stdout: stdout == null ? '' : String(stdout),
+          stderr: stderr == null ? '' : String(stderr),
+        });
+      },
+    );
+    if (opts.input !== undefined && child.stdin) {
+      child.stdin.end(opts.input);
+    }
+  });
+}

package/node_modules/ink/src/_internal/fullscreen.ts

@@ -0,0 +1,9 @@
+import { isEnvTruthy } from './envUtils.js';
+
+// Mouse tracking is a common pain point: it conflicts with terminal-level
+// text selection (users can't copy output anymore) and breaks tmux's own
+// mouse handling. The env var lets users opt out without code changes when
+// they hit one of those scenarios.
+export function isMouseClicksDisabled(): boolean {
+  return isEnvTruthy(process.env['REASONIX_DISABLE_MOUSE']);
+}

package/node_modules/ink/src/_internal/intl.ts

@@ -0,0 +1,13 @@
+// `Intl.Segmenter` construction is surprisingly expensive — measurable on
+// the renderer hot path when called per-character. One module-level instance
+// is enough: the segmenter is stateless across `.segment()` calls and we
+// only ever need grapheme granularity for terminal width calculations.
+
+let cachedSegmenter: Intl.Segmenter | null = null;
+
+export function getGraphemeSegmenter(): Intl.Segmenter {
+  if (!cachedSegmenter) {
+    cachedSegmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+  }
+  return cachedSegmenter;
+}

package/node_modules/ink/src/_internal/iter-lines.ts

@@ -0,0 +1,14 @@
+/** Walk `text` line by line without allocating an intermediate array. */
+export function forEachLine(
+  text: string,
+  visit: (line: string) => void | boolean,
+): void {
+  let start = 0;
+  while (start <= text.length) {
+    const end = text.indexOf('\n', start);
+    const line = end === -1 ? text.substring(start) : text.substring(start, end);
+    if (visit(line) === true) return;
+    if (end === -1) break;
+    start = end + 1;
+  }
+}

package/node_modules/ink/src/_internal/log.ts

@@ -0,0 +1,15 @@
+// Centralised error sink so we have one place to redirect when embedding
+// in a host that owns stderr (e.g. a TUI inside another TUI). Prefer the
+// stack trace when available — for renderer bugs the call chain matters
+// more than the message.
+export function logError(err: unknown): void {
+  const message =
+    err instanceof Error ? err.stack ?? err.message : String(err);
+  // stderr may be closed during shutdown; refusing to log is preferable to
+  // crashing the host application.
+  try {
+    process.stderr.write(`[ink] ${message}\n`);
+  } catch {
+    /* stderr unavailable during shutdown */
+  }
+}

package/node_modules/ink/src/_internal/semver.ts

@@ -0,0 +1,12 @@
+import semver from "semver";
+import { logError } from "./log.js";
+
+/** Tolerant `>=` comparison for terminal-reported version strings. */
+export function gte(a: string, b: string): boolean {
+  try {
+    return semver.gte(semver.coerce(a) ?? a, semver.coerce(b) ?? b);
+  } catch (error) {
+    logError(`semver gte(${a}, ${b}) failed: ${(error as Error).message}`);
+    return false;
+  }
+}

package/node_modules/ink/src/_internal/sliceAnsi.ts

@@ -0,0 +1,6 @@
+// Thin indirection over the upstream `slice-ansi` package. Keeping the
+// dependency behind a local module means we can swap implementations
+// (e.g. for a custom width-aware slicer) without touching every call site.
+import sliceAnsi from 'slice-ansi';
+
+export default sliceAnsi;

package/node_modules/ink/src/_internal/state.ts

@@ -0,0 +1,22 @@
+/** Per-process "last user activity" timestamp. */
+
+let lastInteractionTime = 0;
+
+/** Mark "real user interaction just happened". */
+export function updateLastInteractionTime(): void {
+  lastInteractionTime = Date.now();
+}
+
+/** Reset the timestamp. */
+export function flushInteractionTime(): void {
+  lastInteractionTime = 0;
+}
+
+/** Mark scroll input as user activity. */
+export function markScrollActivity(): void {
+  lastInteractionTime = Date.now();
+}
+
+export function getLastInteractionTime(): number {
+  return lastInteractionTime;
+}

package/node_modules/ink/src/_internal/yoga-layout.ts

@@ -0,0 +1,23 @@
+// Single import boundary for `yoga-layout`. Sibling files re-export through
+// here so a future swap (alternative layout backend, version pin, mock for
+// tests) only has to touch this file.
+import Yoga from 'yoga-layout';
+
+export * from 'yoga-layout';
+export default Yoga;
+
+type YogaCounters = {
+  visited: number;
+  measured: number;
+  cacheHits: number;
+  live: number;
+};
+
+// Diagnostic counters surfaced to renderer telemetry. The TypeScript port of
+// Yoga we use does not expose internal stats, so these are currently zeroed
+// placeholders — kept so call sites (`ink.tsx`, `reconciler.ts`) continue to
+// compile and so we have a hook to wire real numbers in later without an API
+// change.
+export function getYogaCounters(): YogaCounters {
+  return { visited: 0, measured: 0, cacheHits: 0, live: 0 };
+}

package/node_modules/ink/src/ambient.d.ts

@@ -0,0 +1,47 @@
+
+/** `bidi-js` ships without types. */
+declare module 'bidi-js' {
+  type BidiFactory = (
+    text: string,
+    explicitDirection?: string,
+  ) => {
+    paragraphs: Array<{ start: number; end: number; level: number }>;
+    levels: Uint8Array;
+    getReorderSegments(start: number, end: number, levels: Uint8Array): number[][];
+  };
+  const bidiFactory: () => BidiFactory;
+  export default bidiFactory;
+}
+
+declare module 'react-reconciler' {
+  interface Reconciler<C, _I, _T, _R, _P> {
+    updateContainerSync: (
+      element: unknown,
+      container: C,
+      parent: unknown,
+      callback: unknown,
+    ) => unknown;
+    flushSyncWork: () => void;
+    flushSyncFromReconciler: <R>(fn: () => R) => R;
+  }
+}
+
+/** Bun exposes process-level globals that don't exist under Node. */
+// biome-ignore lint/suspicious/noExplicitAny: Bun globals tolerate any payload
+declare const Bun:
+  | undefined
+  | {
+      version?: string;
+      argv?: readonly string[];
+      stringWidth?: (s: string, opts?: unknown) => number;
+      wrapAnsi?: (s: string, cols: number, opts?: unknown) => string;
+    };
+
+declare namespace JSX {
+  interface IntrinsicElements {
+    'ink-box': Record<string, unknown>;
+    'ink-text': Record<string, unknown>;
+    'ink-link': Record<string, unknown>;
+    'ink-raw-ansi': Record<string, unknown>;
+  }
+}

package/node_modules/ink/src/bidi.ts

@@ -0,0 +1,110 @@
+// @ts-nocheck
+/** Software-side bidirectional reordering for clustered terminal cells. */
+import bidiFactory from 'bidi-js';
+
+type ClusteredChar = {
+  value: string;
+  width: number;
+  styleId: number;
+  hyperlink: string | undefined;
+};
+
+let bidiInstance: ReturnType<typeof bidiFactory> | undefined;
+let cachedNeedsBidi: boolean | undefined;
+
+// Windows lacks terminal-side bidi entirely. Windows Terminal hosting WSL
+// still routes output through conhost, so WSL processes inherit the same
+// gap — we detect that via WT_SESSION rather than process.platform. VS Code's
+// xterm.js doesn't implement bidi either and is reachable on any OS.
+function needsSoftwareBidi(): boolean {
+  if (cachedNeedsBidi === undefined) {
+    cachedNeedsBidi =
+      process.platform === 'win32' ||
+      typeof process.env['WT_SESSION'] === 'string' ||
+      process.env['TERM_PROGRAM'] === 'vscode';
+  }
+  return cachedNeedsBidi;
+}
+
+function getBidi() {
+  if (!bidiInstance) {
+    bidiInstance = bidiFactory();
+  }
+  return bidiInstance;
+}
+
+export function reorderBidi(characters: ClusteredChar[]): ClusteredChar[] {
+  if (!needsSoftwareBidi() || characters.length === 0) {
+    return characters;
+  }
+
+  const plainText = characters.map(c => c.value).join('');
+
+  // Probing for RTL code points first lets us skip the bidi-js call entirely
+  // on the dominant LTR-only path — paragraph-level scan with one regex test.
+  if (!hasRtlCharacters(plainText)) {
+    return characters;
+  }
+
+  const bidi = getBidi();
+  const { levels } = bidi.getEmbeddingLevels(plainText, 'auto');
+
+  // bidi-js returns one level per UTF-16 code unit. Walk the cluster array
+  // in parallel, taking the level of the first code unit of each cluster as
+  // the cluster's level — within a cluster all units share a level.
+  const charLevels: number[] = [];
+  let offset = 0;
+  for (let i = 0; i < characters.length; i++) {
+    charLevels.push(levels[offset]!);
+    offset += characters[i]!.value.length;
+  }
+
+  // Classic UBA reorder: from the deepest embedding level down to 1, reverse
+  // each maximal run of clusters whose level is >= the current level. The
+  // result is identical to bidi-js's reorderSegments output but expressed
+  // over cluster indices so we don't have to map back from string offsets.
+  const reordered = [...characters];
+  const maxLevel = Math.max(...charLevels);
+
+  for (let level = maxLevel; level >= 1; level--) {
+    let i = 0;
+    while (i < reordered.length) {
+      if (charLevels[i]! >= level) {
+        let j = i + 1;
+        while (j < reordered.length && charLevels[j]! >= level) {
+          j++;
+        }
+        reverseRange(reordered, i, j - 1);
+        reverseRange(charLevels, i, j - 1);
+        i = j;
+      } else {
+        i++;
+      }
+    }
+  }
+
+  return reordered;
+}
+
+function reverseRange<T>(arr: T[], start: number, end: number): void {
+  while (start < end) {
+    const tmp = arr[start]!;
+    arr[start] = arr[end]!;
+    arr[end] = tmp;
+    start++;
+    end--;
+  }
+}
+
+// Conservative pre-check for any code point that could carry an RTL bidi
+// class. We err on the side of false positives (running the full algorithm
+// on a string that turns out to be neutral is harmless) and avoid false
+// negatives that would leave RTL text visibly reversed.
+//
+// Covers: Hebrew (incl. presentation forms), Arabic (incl. supplement,
+// extended-A, presentation forms A/B), Thaana, and Syriac.
+function hasRtlCharacters(text: string): boolean {
+  return /[\u0590-\u05FF\uFB1D-\uFB4F\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF\u0780-\u07BF\u0700-\u074F]/u.test(
+    text,
+  );
+}