@deepseek-harness-tui/dsh-tui 0.5.0

package/lib/types/ink/termio/sgr.js

@@ -0,0 +1,300 @@
+/**
+ * SGR (Select Graphic Rendition) Parser
+ *
+ * Parses SGR parameters and applies them to a TextStyle.
+ * Handles both semicolon (;) and colon (:) separated parameters.
+ */
+import { defaultStyle } from './types.js';
+const NAMED_COLORS = [
+    'black',
+    'red',
+    'green',
+    'yellow',
+    'blue',
+    'magenta',
+    'cyan',
+    'white',
+    'brightBlack',
+    'brightRed',
+    'brightGreen',
+    'brightYellow',
+    'brightBlue',
+    'brightMagenta',
+    'brightCyan',
+    'brightWhite',
+];
+const UNDERLINE_STYLES = [
+    'none',
+    'single',
+    'double',
+    'curly',
+    'dotted',
+    'dashed',
+];
+function parseParams(str) {
+    if (str === '')
+        return [{ value: 0, subparams: [], colon: false }];
+    const result = [];
+    let current = { value: null, subparams: [], colon: false };
+    let num = '';
+    let inSub = false;
+    for (let i = 0; i <= str.length; i++) {
+        const c = str[i];
+        if (c === ';' || c === undefined) {
+            const n = num === '' ? null : parseInt(num, 10);
+            if (inSub) {
+                if (n !== null)
+                    current.subparams.push(n);
+            }
+            else {
+                current.value = n;
+            }
+            result.push(current);
+            current = { value: null, subparams: [], colon: false };
+            num = '';
+            inSub = false;
+        }
+        else if (c === ':') {
+            const n = num === '' ? null : parseInt(num, 10);
+            if (!inSub) {
+                current.value = n;
+                current.colon = true;
+                inSub = true;
+            }
+            else {
+                if (n !== null)
+                    current.subparams.push(n);
+            }
+            num = '';
+        }
+        else if (c >= '0' && c <= '9') {
+            num += c;
+        }
+    }
+    return result;
+}
+function parseExtendedColor(params, idx) {
+    const p = params[idx];
+    if (!p)
+        return null;
+    if (p.colon && p.subparams.length >= 1) {
+        if (p.subparams[0] === 5 && p.subparams.length >= 2) {
+            return { index: p.subparams[1] };
+        }
+        if (p.subparams[0] === 2 && p.subparams.length >= 4) {
+            const off = p.subparams.length >= 5 ? 1 : 0;
+            return {
+                r: p.subparams[1 + off],
+                g: p.subparams[2 + off],
+                b: p.subparams[3 + off],
+            };
+        }
+    }
+    const next = params[idx + 1];
+    if (!next)
+        return null;
+    if (next.value === 5 &&
+        params[idx + 2]?.value !== null &&
+        params[idx + 2]?.value !== undefined) {
+        return { index: params[idx + 2].value };
+    }
+    if (next.value === 2) {
+        const r = params[idx + 2]?.value;
+        const g = params[idx + 3]?.value;
+        const b = params[idx + 4]?.value;
+        if (r !== null &&
+            r !== undefined &&
+            g !== null &&
+            g !== undefined &&
+            b !== null &&
+            b !== undefined) {
+            return { r, g, b };
+        }
+    }
+    return null;
+}
+/**
+ * Apply an SGR parameter string to a text style.
+ * Handles both semicolon (;) and colon (:) separated parameters.
+ * @param paramStr - the SGR parameter string (without the CSI prefix or final m).
+ * @param style - the style to apply the parameters to.
+ * @returns the resulting style; code 0 resets to the default style, other
+ *   codes update the corresponding attribute of a copy.
+ */
+export function applySGR(paramStr, style) {
+    const params = parseParams(paramStr);
+    let s = { ...style };
+    let i = 0;
+    while (i < params.length) {
+        const p = params[i];
+        const code = p.value ?? 0;
+        if (code === 0) {
+            s = defaultStyle();
+            i++;
+            continue;
+        }
+        if (code === 1) {
+            s.bold = true;
+            i++;
+            continue;
+        }
+        if (code === 2) {
+            s.dim = true;
+            i++;
+            continue;
+        }
+        if (code === 3) {
+            s.italic = true;
+            i++;
+            continue;
+        }
+        if (code === 4) {
+            s.underline = p.colon
+                ? (UNDERLINE_STYLES[p.subparams[0]] ?? 'single')
+                : 'single';
+            i++;
+            continue;
+        }
+        if (code === 5 || code === 6) {
+            s.blink = true;
+            i++;
+            continue;
+        }
+        if (code === 7) {
+            s.inverse = true;
+            i++;
+            continue;
+        }
+        if (code === 8) {
+            s.hidden = true;
+            i++;
+            continue;
+        }
+        if (code === 9) {
+            s.strikethrough = true;
+            i++;
+            continue;
+        }
+        if (code === 21) {
+            s.underline = 'double';
+            i++;
+            continue;
+        }
+        if (code === 22) {
+            s.bold = false;
+            s.dim = false;
+            i++;
+            continue;
+        }
+        if (code === 23) {
+            s.italic = false;
+            i++;
+            continue;
+        }
+        if (code === 24) {
+            s.underline = 'none';
+            i++;
+            continue;
+        }
+        if (code === 25) {
+            s.blink = false;
+            i++;
+            continue;
+        }
+        if (code === 27) {
+            s.inverse = false;
+            i++;
+            continue;
+        }
+        if (code === 28) {
+            s.hidden = false;
+            i++;
+            continue;
+        }
+        if (code === 29) {
+            s.strikethrough = false;
+            i++;
+            continue;
+        }
+        if (code === 53) {
+            s.overline = true;
+            i++;
+            continue;
+        }
+        if (code === 55) {
+            s.overline = false;
+            i++;
+            continue;
+        }
+        if (code >= 30 && code <= 37) {
+            s.fg = { type: 'named', name: NAMED_COLORS[code - 30] };
+            i++;
+            continue;
+        }
+        if (code === 39) {
+            s.fg = { type: 'default' };
+            i++;
+            continue;
+        }
+        if (code >= 40 && code <= 47) {
+            s.bg = { type: 'named', name: NAMED_COLORS[code - 40] };
+            i++;
+            continue;
+        }
+        if (code === 49) {
+            s.bg = { type: 'default' };
+            i++;
+            continue;
+        }
+        if (code >= 90 && code <= 97) {
+            s.fg = { type: 'named', name: NAMED_COLORS[code - 90 + 8] };
+            i++;
+            continue;
+        }
+        if (code >= 100 && code <= 107) {
+            s.bg = { type: 'named', name: NAMED_COLORS[code - 100 + 8] };
+            i++;
+            continue;
+        }
+        if (code === 38) {
+            const c = parseExtendedColor(params, i);
+            if (c) {
+                s.fg =
+                    'index' in c
+                        ? { type: 'indexed', index: c.index }
+                        : { type: 'rgb', ...c };
+                i += p.colon ? 1 : 'index' in c ? 3 : 5;
+                continue;
+            }
+        }
+        if (code === 48) {
+            const c = parseExtendedColor(params, i);
+            if (c) {
+                s.bg =
+                    'index' in c
+                        ? { type: 'indexed', index: c.index }
+                        : { type: 'rgb', ...c };
+                i += p.colon ? 1 : 'index' in c ? 3 : 5;
+                continue;
+            }
+        }
+        if (code === 58) {
+            const c = parseExtendedColor(params, i);
+            if (c) {
+                s.underlineColor =
+                    'index' in c
+                        ? { type: 'indexed', index: c.index }
+                        : { type: 'rgb', ...c };
+                i += p.colon ? 1 : 'index' in c ? 3 : 5;
+                continue;
+            }
+        }
+        if (code === 59) {
+            s.underlineColor = { type: 'default' };
+            i++;
+            continue;
+        }
+        i++;
+    }
+    return s;
+}

package/lib/types/ink/termio/tokenize.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Input Tokenizer - Escape sequence boundary detection
+ *
+ * Splits terminal input into tokens: text chunks and raw escape sequences.
+ * Unlike the Parser which interprets sequences semantically, this just
+ * identifies boundaries for use by keyboard input parsing.
+ */
+/** A chunk of terminal input: plain text or a raw escape sequence. */
+export type Token = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'sequence';
+    value: string;
+};
+/** Streaming tokenizer for terminal input, buffering incomplete sequences. */
+export type Tokenizer = {
+    /** Feed input and get resulting tokens */
+    feed(input: string): Token[];
+    /** Flush any buffered incomplete sequences */
+    flush(): Token[];
+    /** Reset tokenizer state */
+    reset(): void;
+    /** Get any buffered incomplete sequence */
+    buffer(): string;
+};
+type TokenizerOptions = {
+    /**
+     * Treat `CSI M` as an X10 mouse event prefix and consume 3 payload bytes.
+     * Only enable for stdin input — `\x1b[M` is also CSI DL (Delete Lines) in
+     * output streams, and enabling this there swallows display text. Default false.
+     */
+    x10Mouse?: boolean;
+};
+/**
+ * Create a streaming tokenizer for terminal input.
+ *
+ * Usage:
+ * ```typescript
+ * const tokenizer = createTokenizer()
+ * const tokens1 = tokenizer.feed('hello\x1b[')
+ * const tokens2 = tokenizer.feed('A')  // completes the escape sequence
+ * const remaining = tokenizer.flush()  // force output incomplete sequences
+ * ```
+ * @param options - tokenizer options; when omitted all defaults apply.
+ * @returns the tokenizer instance.
+ */
+export declare function createTokenizer(options?: TokenizerOptions): Tokenizer;
+export {};
+//# sourceMappingURL=tokenize.d.ts.map

package/lib/types/ink/termio/tokenize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenize.d.ts","sourceRoot":"","sources":["../../../../src/ink/termio/tokenize.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,sEAAsE;AACtE,MAAM,MAAM,KAAK,GACb;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAYvC,8EAA8E;AAC9E,MAAM,MAAM,SAAS,GAAG;IACtB,0CAA0C;IAC1C,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,CAAA;IAC5B,8CAA8C;IAC9C,KAAK,IAAI,KAAK,EAAE,CAAA;IAChB,4BAA4B;IAC5B,KAAK,IAAI,IAAI,CAAA;IACb,2CAA2C;IAC3C,MAAM,IAAI,MAAM,CAAA;CACjB,CAAA;AAED,KAAK,gBAAgB,GAAG;IACtB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAmCrE"}

package/lib/types/ink/termio/tokenize.js

@@ -0,0 +1,266 @@
+/**
+ * Input Tokenizer - Escape sequence boundary detection
+ *
+ * Splits terminal input into tokens: text chunks and raw escape sequences.
+ * Unlike the Parser which interprets sequences semantically, this just
+ * identifies boundaries for use by keyboard input parsing.
+ */
+import { C0, ESC_TYPE, isEscFinal } from './ansi.js';
+import { isCSIFinal, isCSIIntermediate, isCSIParam } from './csi.js';
+/**
+ * Create a streaming tokenizer for terminal input.
+ *
+ * Usage:
+ * ```typescript
+ * const tokenizer = createTokenizer()
+ * const tokens1 = tokenizer.feed('hello\x1b[')
+ * const tokens2 = tokenizer.feed('A')  // completes the escape sequence
+ * const remaining = tokenizer.flush()  // force output incomplete sequences
+ * ```
+ * @param options - tokenizer options; when omitted all defaults apply.
+ * @returns the tokenizer instance.
+ */
+export function createTokenizer(options) {
+    let currentState = 'ground';
+    let currentBuffer = '';
+    const x10Mouse = options?.x10Mouse ?? false;
+    return {
+        feed(input) {
+            const result = tokenize(input, currentState, currentBuffer, false, x10Mouse);
+            currentState = result.state.state;
+            currentBuffer = result.state.buffer;
+            return result.tokens;
+        },
+        flush() {
+            const result = tokenize('', currentState, currentBuffer, true, x10Mouse);
+            currentState = result.state.state;
+            currentBuffer = result.state.buffer;
+            return result.tokens;
+        },
+        reset() {
+            currentState = 'ground';
+            currentBuffer = '';
+        },
+        buffer() {
+            return currentBuffer;
+        },
+    };
+}
+function tokenize(input, initialState, initialBuffer, flush, x10Mouse) {
+    const tokens = [];
+    const result = {
+        state: initialState,
+        buffer: '',
+    };
+    const data = initialBuffer + input;
+    let i = 0;
+    let textStart = 0;
+    let seqStart = 0;
+    const flushText = () => {
+        if (i > textStart) {
+            const text = data.slice(textStart, i);
+            if (text) {
+                tokens.push({ type: 'text', value: text });
+            }
+        }
+        textStart = i;
+    };
+    const emitSequence = (seq) => {
+        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
+                    result.state = 'ss3';
+                    i++;
+                }
+                else if (isCSIIntermediate(code)) {
+                    // Intermediate byte (e.g., ESC ( for charset) - continue buffering
+                    result.state = 'escapeIntermediate';
+                    i++;
+                }
+                else if (isEscFinal(code)) {
+                    // Two-character escape sequence
+                    i++;
+                    emitSequence(data.slice(seqStart, i));
+                }
+                else if (code === C0.ESC) {
+                    // Double escape - emit first, start new
+                    emitSequence(data.slice(seqStart, i));
+                    seqStart = i;
+                    result.state = 'escape';
+                    i++;
+                }
+                else {
+                    // Invalid - treat ESC as text
+                    result.state = 'ground';
+                    textStart = seqStart;
+                }
+                break;
+            case 'escapeIntermediate':
+                // After intermediate byte(s), wait for final byte
+                if (isCSIIntermediate(code)) {
+                    // More intermediate bytes
+                    i++;
+                }
+                else if (isEscFinal(code)) {
+                    // Final byte - complete the sequence
+                    i++;
+                    emitSequence(data.slice(seqStart, i));
+                }
+                else {
+                    // Invalid - treat as text
+                    result.state = 'ground';
+                    textStart = seqStart;
+                }
+                break;
+            case 'csi':
+                // X10 mouse: CSI M + 3 raw payload bytes (Cb+32, Cx+32, Cy+32).
+                // M immediately after [ (offset 2) means no params — SGR mouse
+                // (CSI < … M) has a `<` param byte first and reaches M at offset > 2.
+                // Terminals that ignore DECSET 1006 but honor 1000/1002 emit this
+                // legacy encoding; without this branch the 3 payload bytes leak
+                // through as text (`` `rK `` / `arK` garbage in the prompt).
+                //
+                // Gated on x10Mouse — `\x1b[M` is also CSI DL (Delete Lines) and
+                // blindly consuming 3 chars corrupts output rendering (Parser/Ansi)
+                // and fragments bracketed-paste PASTE_END. Only stdin enables this.
+                // The ≥0x20 check on each payload slot is belt-and-suspenders: X10
+                // guarantees Cb≥32, Cx≥33, Cy≥33, so a control byte (ESC=0x1B) in
+                // any slot means this is CSI DL adjacent to another sequence, not a
+                // mouse event. Checking all three slots prevents PASTE_END's ESC
+                // from being consumed when paste content ends in `\x1b[M`+0-2 chars.
+                //
+                // Known limitation: this counts JS string chars, but X10 is byte-
+                // oriented and stdin uses utf8 encoding (App.tsx). At col 162-191 ×
+                // row 96-159 the two coord bytes (0xC2-0xDF, 0x80-0xBF) form a valid
+                // UTF-8 2-byte sequence and collapse to one char — the length check
+                // fails and the event buffers until the next keypress absorbs it.
+                // Fixing this requires latin1 stdin; X10's 223-coord cap is exactly
+                // why SGR was invented, and no-SGR terminals at 162+ cols are rare.
+                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 — exit loop; end-of-input buffers from seqStart.
+                        // Re-entry re-tokenizes from ground via the invalid-CSI fallthrough.
+                        i = data.length;
+                    }
+                    break;
+                }
+                if (isCSIFinal(code)) {
+                    i++;
+                    emitSequence(data.slice(seqStart, i));
+                }
+                else if (isCSIParam(code) || isCSIIntermediate(code)) {
+                    i++;
+                }
+                else {
+                    // Invalid CSI - abort, treat as text
+                    result.state = 'ground';
+                    textStart = seqStart;
+                }
+                break;
+            case 'ss3':
+                // SS3 sequences: ESC O followed by a single final byte
+                if (code >= 0x40 && code <= 0x7e) {
+                    i++;
+                    emitSequence(data.slice(seqStart, i));
+                }
+                else {
+                    // Invalid - treat as text
+                    result.state = 'ground';
+                    textStart = seqStart;
+                }
+                break;
+            case 'osc':
+                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':
+                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;
+        }
+    }
+    // Handle end of input
+    if (result.state === 'ground') {
+        flushText();
+    }
+    else if (flush) {
+        // Force output incomplete sequence
+        const remaining = data.slice(seqStart);
+        if (remaining)
+            tokens.push({ type: 'sequence', value: remaining });
+        result.state = 'ground';
+    }
+    else {
+        // Buffer incomplete sequence for next call
+        result.buffer = data.slice(seqStart);
+    }
+    return { tokens, state: result };
+}