mimo-reasonix 0.1.0 → 0.1.1

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

@@ -0,0 +1,311 @@
+
+import { C0, ESC_TYPE, isEscFinal } from './ansi.js'
+import { isCSIFinal, isCSIIntermediate, isCSIParam } from './csi.js'
+
+export type Token =
+  | { type: 'text'; value: string }
+  | { type: 'sequence'; value: string }
+
+type State =
+  | 'ground'
+  | 'escape'
+  | 'escapeIntermediate'
+  | 'csi'
+  | 'ss3'
+  | 'osc'
+  | 'dcs'
+  | 'apc'
+
+export type Tokenizer = {
+  /** Feed input and return the tokens it completes. */
+  feed(input: string): Token[]
+  /** Force any buffered incomplete sequence out as a sequence token. */
+  flush(): Token[]
+  /** Drop all state — used between unrelated input chunks. */
+  reset(): void
+  /** Inspect the current incomplete sequence buffer. */
+  buffer(): string
+}
+
+type TokenizerOptions = {
+  x10Mouse?: boolean
+}
+
+/** Create a streaming tokenizer for terminal input. */
+export function createTokenizer(options?: TokenizerOptions): Tokenizer {
+  let currentState: State = 'ground'
+  let currentBuffer = ''
+  const x10Mouse = options?.x10Mouse ?? false
+
+  return {
+    feed(input: string): Token[] {
+      const result = tokenize(
+        input,
+        currentState,
+        currentBuffer,
+        false,
+        x10Mouse,
+      )
+      currentState = result.state.state
+      currentBuffer = result.state.buffer
+      return result.tokens
+    },
+
+    flush(): Token[] {
+      const result = tokenize('', currentState, currentBuffer, true, x10Mouse)
+      currentState = result.state.state
+      currentBuffer = result.state.buffer
+      return result.tokens
+    },
+
+    reset(): void {
+      currentState = 'ground'
+      currentBuffer = ''
+    },
+
+    buffer(): string {
+      return currentBuffer
+    },
+  }
+}
+
+type InternalState = {
+  state: State
+  buffer: string
+}
+
+/** Single-pass tokenizer driver. */
+function tokenize(
+  input: string,
+  initialState: State,
+  initialBuffer: string,
+  flush: boolean,
+  x10Mouse: boolean,
+): { tokens: Token[]; state: InternalState } {
+  const tokens: Token[] = []
+  const result: InternalState = {
+    state: initialState,
+    buffer: '',
+  }
+
+  const data = initialBuffer + input
+  let i = 0
+  let textStart = 0
+  let seqStart = 0
+
+  const flushText = (): void => {
+    if (i > textStart) {
+      const text = data.slice(textStart, i)
+      if (text) {
+        tokens.push({ type: 'text', value: text })
+      }
+    }
+    textStart = i
+  }
+
+  const emitSequence = (seq: string): void => {
+    if (seq) {
+      tokens.push({ type: 'sequence', value: seq })
+    }
+    result.state = 'ground'
+    textStart = i
+  }
+
+  while (i < data.length) {
+    const code = data.charCodeAt(i)
+
+    switch (result.state) {
+      case 'ground':
+        if (code === C0.ESC) {
+          flushText()
+          seqStart = i
+          result.state = 'escape'
+          i++
+        } else {
+          i++
+        }
+        break
+
+      case 'escape':
+        if (code === ESC_TYPE.CSI) {
+          result.state = 'csi'
+          i++
+        } else if (code === ESC_TYPE.OSC) {
+          result.state = 'osc'
+          i++
+        } else if (code === ESC_TYPE.DCS) {
+          result.state = 'dcs'
+          i++
+        } else if (code === ESC_TYPE.APC) {
+          result.state = 'apc'
+          i++
+        } else if (code === 0x4f) {
+          // 'O' — SS3 (single shift to G3, used by some keypad keys).
+          result.state = 'ss3'
+          i++
+        } else if (isCSIIntermediate(code)) {
+          // ESC followed by an intermediate byte (e.g. `ESC (` for
+          // charset designation). Stay in the buffer until we see a
+          // final byte.
+          result.state = 'escapeIntermediate'
+          i++
+        } else if (isEscFinal(code)) {
+          // A two-byte ESC sequence (ESC c, ESC 7, ESC =, …).
+          i++
+          emitSequence(data.slice(seqStart, i))
+        } else if (code === C0.ESC) {
+          // Two ESCs in a row: emit the first as its own sequence and
+          // restart. Real terminals send this when a user presses Alt
+          // and the keymap layer hadn't started a proper modifier seq.
+          emitSequence(data.slice(seqStart, i))
+          seqStart = i
+          result.state = 'escape'
+          i++
+        } else {
+          // Unparseable — drop the ESC marker and reinterpret the byte
+          // as text starting from where the ESC was.
+          result.state = 'ground'
+          textStart = seqStart
+        }
+        break
+
+      case 'escapeIntermediate':
+        if (isCSIIntermediate(code)) {
+          i++
+        } else if (isEscFinal(code)) {
+          i++
+          emitSequence(data.slice(seqStart, i))
+        } else {
+          result.state = 'ground'
+          textStart = seqStart
+        }
+        break
+
+      case 'csi':
+        // X10 mouse event: `CSI M` followed by three raw payload bytes
+        // (Cb+32, Cx+32, Cy+32). This branch is gated on x10Mouse
+        // because for output parsing `CSI M` is the Delete Lines (DL)
+        // command, and consuming the three following bytes there would
+        // corrupt the output stream.
+        //
+        // The `i - seqStart === 2` check enforces that M is the very
+        // first byte after `[`. SGR mouse (`CSI < … M`) has a `<` param
+        // byte first and reaches M at offset > 2 — that path falls
+        // through to the normal isCSIFinal branch.
+        //
+        // The ≥0x20 checks on each payload slot are belt-and-suspenders:
+        // X10 guarantees Cb ≥ 32 (and the coords ≥ 33), so a control
+        // byte (ESC = 0x1B) in any slot means we're actually looking at
+        // CSI DL adjacent to another sequence, not a mouse event. We
+        // need to check all three slots, not just the first — when a
+        // paste happens to end in `\x1b[M` + 0–2 chars, PASTE_END's ESC
+        // sits in one of those slots and we mustn't swallow it.
+        //
+        // Known limitation: this counts JavaScript string code units,
+        // but X10 is byte-oriented and stdin uses UTF-8 encoding. At
+        // column 162-191 × row 96-159 the two coordinate bytes
+        // (0xC2-0xDF, 0x80-0xBF) form a valid UTF-8 two-byte sequence
+        // and collapse to a single code unit — the 4-character look-
+        // ahead fails and the event sits in the buffer until the next
+        // keypress completes it. Fixing this requires switching stdin
+        // to latin1, which has wider downsides; X10's 223-column cap is
+        // the reason SGR mouse (mode 1006) exists, and terminals that
+        // don't support SGR at 162+ columns are essentially extinct.
+        if (
+          x10Mouse &&
+          code === 0x4d /* M */ &&
+          i - seqStart === 2 &&
+          (i + 1 >= data.length || data.charCodeAt(i + 1) >= 0x20) &&
+          (i + 2 >= data.length || data.charCodeAt(i + 2) >= 0x20) &&
+          (i + 3 >= data.length || data.charCodeAt(i + 3) >= 0x20)
+        ) {
+          if (i + 4 <= data.length) {
+            i += 4
+            emitSequence(data.slice(seqStart, i))
+          } else {
+            // Incomplete payload — exit the loop and let the
+            // end-of-input handling buffer from seqStart. On re-entry
+            // we'll re-tokenize from ground via the invalid-CSI path.
+            i = data.length
+          }
+          break
+        }
+        if (isCSIFinal(code)) {
+          i++
+          emitSequence(data.slice(seqStart, i))
+        } else if (isCSIParam(code) || isCSIIntermediate(code)) {
+          i++
+        } else {
+          // Malformed CSI — drop the introducer and replay as text.
+          result.state = 'ground'
+          textStart = seqStart
+        }
+        break
+
+      case 'ss3':
+        // SS3 = ESC O + one final byte (0x40-0x7E).
+        if (code >= 0x40 && code <= 0x7e) {
+          i++
+          emitSequence(data.slice(seqStart, i))
+        } else {
+          result.state = 'ground'
+          textStart = seqStart
+        }
+        break
+
+      case 'osc':
+        // OSC terminates on BEL or on `ESC \` (ST). We accept both
+        // because terminals are inconsistent about which they emit.
+        if (code === C0.BEL) {
+          i++
+          emitSequence(data.slice(seqStart, i))
+        } else if (
+          code === C0.ESC &&
+          i + 1 < data.length &&
+          data.charCodeAt(i + 1) === ESC_TYPE.ST
+        ) {
+          i += 2
+          emitSequence(data.slice(seqStart, i))
+        } else {
+          i++
+        }
+        break
+
+      case 'dcs':
+      case 'apc':
+        // DCS and APC use the same terminator rules as OSC. We don't
+        // interpret their payloads here — they're typically tmux
+        // passthrough or kitty graphics, handed off as raw sequences.
+        if (code === C0.BEL) {
+          i++
+          emitSequence(data.slice(seqStart, i))
+        } else if (
+          code === C0.ESC &&
+          i + 1 < data.length &&
+          data.charCodeAt(i + 1) === ESC_TYPE.ST
+        ) {
+          i += 2
+          emitSequence(data.slice(seqStart, i))
+        } else {
+          i++
+        }
+        break
+    }
+  }
+
+  if (result.state === 'ground') {
+    flushText()
+  } else if (flush) {
+    // Caller asked for an explicit flush — best-effort emit whatever's
+    // accumulated as a sequence token, even if the bytes don't form a
+    // complete sequence.
+    const remaining = data.slice(seqStart)
+    if (remaining) tokens.push({ type: 'sequence', value: remaining })
+    result.state = 'ground'
+  } else {
+    // Hold the partial sequence for the next feed call.
+    result.buffer = data.slice(seqStart)
+  }
+
+  return { tokens, state: result }
+}

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

@@ -0,0 +1,225 @@
+/** Semantic types for the ANSI parser. */
+
+// ---------------------------------------------------------------------------
+// Colours
+// ---------------------------------------------------------------------------
+
+/** Named colours from the 16-colour ANSI palette. */
+export type NamedColor =
+  | 'black'
+  | 'red'
+  | 'green'
+  | 'yellow'
+  | 'blue'
+  | 'magenta'
+  | 'cyan'
+  | 'white'
+  | 'brightBlack'
+  | 'brightRed'
+  | 'brightGreen'
+  | 'brightYellow'
+  | 'brightBlue'
+  | 'brightMagenta'
+  | 'brightCyan'
+  | 'brightWhite'
+
+/** Colour specification. */
+export type Color =
+  | { type: 'named'; name: NamedColor }
+  | { type: 'indexed'; index: number } // 0–255 palette
+  | { type: 'rgb'; r: number; g: number; b: number }
+  | { type: 'default' }
+
+// ---------------------------------------------------------------------------
+// Text style
+// ---------------------------------------------------------------------------
+
+/** Underline variants — `none` is distinct from the bool-ish absence. */
+export type UnderlineStyle =
+  | 'none'
+  | 'single'
+  | 'double'
+  | 'curly'
+  | 'dotted'
+  | 'dashed'
+
+/** Per-cell style state. */
+export type TextStyle = {
+  bold: boolean
+  dim: boolean
+  italic: boolean
+  underline: UnderlineStyle
+  blink: boolean
+  inverse: boolean
+  hidden: boolean
+  strikethrough: boolean
+  overline: boolean
+  fg: Color
+  bg: Color
+  underlineColor: Color
+}
+
+export function defaultStyle(): TextStyle {
+  return {
+    bold: false,
+    dim: false,
+    italic: false,
+    underline: 'none',
+    blink: false,
+    inverse: false,
+    hidden: false,
+    strikethrough: false,
+    overline: false,
+    fg: { type: 'default' },
+    bg: { type: 'default' },
+    underlineColor: { type: 'default' },
+  }
+}
+
+/** Deep equality on two styles. Used by the diff loop to skip unchanged cells. */
+export function stylesEqual(a: TextStyle, b: TextStyle): boolean {
+  return (
+    a.bold === b.bold &&
+    a.dim === b.dim &&
+    a.italic === b.italic &&
+    a.underline === b.underline &&
+    a.blink === b.blink &&
+    a.inverse === b.inverse &&
+    a.hidden === b.hidden &&
+    a.strikethrough === b.strikethrough &&
+    a.overline === b.overline &&
+    colorsEqual(a.fg, b.fg) &&
+    colorsEqual(a.bg, b.bg) &&
+    colorsEqual(a.underlineColor, b.underlineColor)
+  )
+}
+
+/** Deep equality on two colours. */
+export function colorsEqual(a: Color, b: Color): boolean {
+  if (a.type !== b.type) return false
+  switch (a.type) {
+    case 'named':
+      return a.name === (b as typeof a).name
+    case 'indexed':
+      return a.index === (b as typeof a).index
+    case 'rgb':
+      return (
+        a.r === (b as typeof a).r &&
+        a.g === (b as typeof a).g &&
+        a.b === (b as typeof a).b
+      )
+    case 'default':
+      return true
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Cursor actions
+// ---------------------------------------------------------------------------
+
+export type CursorDirection = 'up' | 'down' | 'forward' | 'back'
+
+export type CursorAction =
+  | { type: 'move'; direction: CursorDirection; count: number }
+  | { type: 'position'; row: number; col: number }
+  | { type: 'column'; col: number }
+  | { type: 'row'; row: number }
+  | { type: 'save' }
+  | { type: 'restore' }
+  | { type: 'show' }
+  | { type: 'hide' }
+  | {
+      type: 'style'
+      style: 'block' | 'underline' | 'bar'
+      blinking: boolean
+    }
+  | { type: 'nextLine'; count: number }
+  | { type: 'prevLine'; count: number }
+
+// ---------------------------------------------------------------------------
+// Erase actions
+// ---------------------------------------------------------------------------
+
+export type EraseAction =
+  | { type: 'display'; region: 'toEnd' | 'toStart' | 'all' | 'scrollback' }
+  | { type: 'line'; region: 'toEnd' | 'toStart' | 'all' }
+  | { type: 'chars'; count: number }
+
+// ---------------------------------------------------------------------------
+// Scroll actions
+// ---------------------------------------------------------------------------
+
+export type ScrollAction =
+  | { type: 'up'; count: number }
+  | { type: 'down'; count: number }
+  | { type: 'setRegion'; top: number; bottom: number }
+
+// ---------------------------------------------------------------------------
+// Mode actions
+// ---------------------------------------------------------------------------
+
+export type ModeAction =
+  | { type: 'alternateScreen'; enabled: boolean }
+  | { type: 'bracketedPaste'; enabled: boolean }
+  | { type: 'mouseTracking'; mode: 'off' | 'normal' | 'button' | 'any' }
+  | { type: 'focusEvents'; enabled: boolean }
+
+// ---------------------------------------------------------------------------
+// Link actions (OSC 8)
+// ---------------------------------------------------------------------------
+
+export type LinkAction =
+  | { type: 'start'; url: string; params?: Record<string, string> }
+  | { type: 'end' }
+
+// ---------------------------------------------------------------------------
+// Title actions (OSC 0/1/2)
+// ---------------------------------------------------------------------------
+
+export type TitleAction =
+  | { type: 'windowTitle'; title: string }
+  | { type: 'iconName'; name: string }
+  | { type: 'both'; title: string }
+
+// ---------------------------------------------------------------------------
+// Tab status action (OSC 21337)
+// ---------------------------------------------------------------------------
+
+/** Per-tab chrome metadata. */
+export type TabStatusAction = {
+  indicator?: Color | null
+  status?: string | null
+  statusColor?: Color | null
+}
+
+// ---------------------------------------------------------------------------
+// Parsed segments — the output of the parser
+// ---------------------------------------------------------------------------
+
+/** A styled run of text. */
+export type TextSegment = {
+  type: 'text'
+  text: string
+  style: TextStyle
+}
+
+/** A visual character unit pre-tagged with its display width. */
+export type Grapheme = {
+  value: string
+  width: 1 | 2
+}
+
+/** Discriminated union of everything the parser can emit. */
+export type Action =
+  | { type: 'text'; graphemes: Grapheme[]; style: TextStyle }
+  | { type: 'cursor'; action: CursorAction }
+  | { type: 'erase'; action: EraseAction }
+  | { type: 'scroll'; action: ScrollAction }
+  | { type: 'mode'; action: ModeAction }
+  | { type: 'link'; action: LinkAction }
+  | { type: 'title'; action: TitleAction }
+  | { type: 'tabStatus'; action: TabStatusAction }
+  | { type: 'sgr'; params: string } // raw SGR body, applied to style state
+  | { type: 'bell' }
+  | { type: 'reset' } // full terminal reset (ESC c)
+  | { type: 'unknown'; sequence: string } // unrecognised sequence, opaque

package/node_modules/ink/src/termio.ts

@@ -0,0 +1,20 @@
+export { Parser } from './termio/parser.js';
+
+export type {
+  Action,
+  Color,
+  CursorAction,
+  CursorDirection,
+  EraseAction,
+  Grapheme,
+  LinkAction,
+  ModeAction,
+  NamedColor,
+  ScrollAction,
+  TextSegment,
+  TextStyle,
+  TitleAction,
+  UnderlineStyle,
+} from './termio/types.js';
+
+export { colorsEqual, defaultStyle, stylesEqual } from './termio/types.js';

package/node_modules/ink/src/useTerminalNotification.ts

@@ -0,0 +1,124 @@
+import { createContext, useCallback, useContext, useMemo } from 'react';
+import { isProgressReportingAvailable, type Progress } from './terminal.js';
+import { BEL } from './termio/ansi.js';
+import { ITERM2, OSC, osc, PROGRESS, wrapForMultiplexer } from './termio/osc.js';
+
+type WriteRaw = (data: string) => void;
+
+export const TerminalWriteContext = createContext<WriteRaw | null>(null);
+
+export const TerminalWriteProvider = TerminalWriteContext.Provider;
+
+export type TerminalNotification = {
+  notifyITerm2: (opts: { message: string; title?: string }) => void;
+  notifyKitty: (opts: { message: string; title: string; id: number }) => void;
+  notifyGhostty: (opts: { message: string; title: string }) => void;
+  notifyBell: () => void;
+  /** Report progress to the terminal via OSC 9;4. */
+  progress: (state: Progress['state'] | null, percentage?: number) => void;
+};
+
+export function useTerminalNotification(): TerminalNotification {
+  const writeRaw = useContext(TerminalWriteContext);
+  if (!writeRaw) {
+    throw new Error(
+      'useTerminalNotification must be used within TerminalWriteProvider',
+    );
+  }
+
+  const notifyITerm2 = useCallback(
+    ({ message, title }: { message: string; title?: string }) => {
+      const displayString = title ? `${title}:\n${message}` : message;
+      writeRaw(wrapForMultiplexer(osc(OSC.ITERM2, `\n\n${displayString}`)));
+    },
+    [writeRaw],
+  );
+
+  const notifyKitty = useCallback(
+    ({
+      message,
+      title,
+      id,
+    }: {
+      message: string;
+      title: string;
+      id: number;
+    }) => {
+      // Kitty's notification protocol is three-part: set the title, set the
+      // body, then commit with the focus action. The `i=` id ties the parts
+      // together; `d=0` means "more parts coming", `d=1` means commit.
+      writeRaw(wrapForMultiplexer(osc(OSC.KITTY, `i=${id}:d=0:p=title`, title)));
+      writeRaw(wrapForMultiplexer(osc(OSC.KITTY, `i=${id}:p=body`, message)));
+      writeRaw(wrapForMultiplexer(osc(OSC.KITTY, `i=${id}:d=1:a=focus`, '')));
+    },
+    [writeRaw],
+  );
+
+  const notifyGhostty = useCallback(
+    ({ message, title }: { message: string; title: string }) => {
+      writeRaw(wrapForMultiplexer(osc(OSC.GHOSTTY, 'notify', title, message)));
+    },
+    [writeRaw],
+  );
+
+  const notifyBell = useCallback(() => {
+    // Emit raw BEL with no multiplexer wrap. Inside tmux this triggers the
+    // bell-action (window flag), which is useful as a fallback for callers
+    // that can't enumerate the host terminal's notification protocol.
+    // Wrapping would turn BEL into an opaque DCS payload and lose that.
+    writeRaw(BEL);
+  }, [writeRaw]);
+
+  const progress = useCallback(
+    (state: Progress['state'] | null, percentage?: number) => {
+      if (!isProgressReportingAvailable()) {
+        return;
+      }
+      if (!state) {
+        writeRaw(
+          wrapForMultiplexer(
+            osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.CLEAR, ''),
+          ),
+        );
+        return;
+      }
+      const pct = Math.max(0, Math.min(100, Math.round(percentage ?? 0)));
+      switch (state) {
+        case 'completed':
+          writeRaw(
+            wrapForMultiplexer(
+              osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.CLEAR, ''),
+            ),
+          );
+          break;
+        case 'error':
+          writeRaw(
+            wrapForMultiplexer(
+              osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.ERROR, pct),
+            ),
+          );
+          break;
+        case 'indeterminate':
+          writeRaw(
+            wrapForMultiplexer(
+              osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.INDETERMINATE, ''),
+            ),
+          );
+          break;
+        case 'running':
+          writeRaw(
+            wrapForMultiplexer(
+              osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.SET, pct),
+            ),
+          );
+          break;
+      }
+    },
+    [writeRaw],
+  );
+
+  return useMemo(
+    () => ({ notifyITerm2, notifyKitty, notifyGhostty, notifyBell, progress }),
+    [notifyITerm2, notifyKitty, notifyGhostty, notifyBell, progress],
+  );
+}

package/node_modules/ink/src/warn.ts

@@ -0,0 +1,10 @@
+import { logForDebugging } from './_internal/debug.js';
+
+/** Emit a debug-channel warning when `value` is set but isn't an integer. */
+export function ifNotInteger(value: number | undefined, name: string): void {
+  if (value === undefined) return;
+  if (Number.isInteger(value)) return;
+  logForDebugging(`${name} should be an integer, got ${value}`, {
+    level: 'warn',
+  });
+}

package/node_modules/ink/src/widest-line.ts

@@ -0,0 +1,12 @@
+import { forEachLine } from './_internal/iter-lines.js';
+import { lineWidth } from './line-width-cache.js';
+
+/** Visual width of the widest line in `text`. */
+export function widestLine(text: string): number {
+  let max = 0;
+  forEachLine(text, (line) => {
+    const w = lineWidth(line);
+    if (w > max) max = w;
+  });
+  return max;
+}