@deepseek-harness-tui/dsh-tui 0.5.0

package/lib/types/ink/Ansi.js

@@ -0,0 +1,269 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import Link from './components/Link.js';
+import Text from './components/Text.js';
+import { Parser } from './termio.js';
+/**
+ * Component that parses ANSI escape codes and renders them using Text components.
+ *
+ * Use this as an escape hatch when you have pre-formatted ANSI strings from
+ * external tools (like cli-highlight) that need to be rendered in Ink.
+ *
+ * Memoized to prevent re-renders when parent changes but children string is the same.
+ */
+export const Ansi = React.memo(function Ansi(t0) {
+    const $ = _c(12);
+    const { children, dimColor } = t0;
+    if (typeof children !== "string") {
+        let t1;
+        if ($[0] !== children || $[1] !== dimColor) {
+            t1 = dimColor ? _jsx(Text, { dim: true, children: String(children) }) : _jsx(Text, { children: String(children) });
+            $[0] = children;
+            $[1] = dimColor;
+            $[2] = t1;
+        }
+        else {
+            t1 = $[2];
+        }
+        return t1;
+    }
+    if (children === "") {
+        return null;
+    }
+    let t1;
+    let t2;
+    if ($[3] !== children || $[4] !== dimColor) {
+        t2 = Symbol.for("react.early_return_sentinel");
+        bb0: {
+            const spans = parseToSpans(children);
+            if (spans.length === 0) {
+                t2 = null;
+                break bb0;
+            }
+            if (spans.length === 1 && !hasAnyProps(spans[0].props)) {
+                t2 = dimColor ? _jsx(Text, { dim: true, children: spans[0].text }) : _jsx(Text, { children: spans[0].text });
+                break bb0;
+            }
+            let t3;
+            if ($[7] !== dimColor) {
+                t3 = (span, i) => {
+                    const hyperlink = span.props.hyperlink;
+                    if (dimColor) {
+                        span.props.dim = true;
+                    }
+                    const hasTextProps = hasAnyTextProps(span.props);
+                    if (hyperlink) {
+                        return hasTextProps ? _jsx(Link, { url: hyperlink, children: _jsx(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, children: span.text }) }, i) : _jsx(Link, { url: hyperlink, children: span.text }, i);
+                    }
+                    return hasTextProps ? _jsx(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, children: span.text }, i) : span.text;
+                };
+                $[7] = dimColor;
+                $[8] = t3;
+            }
+            else {
+                t3 = $[8];
+            }
+            t1 = spans.map(t3);
+        }
+        $[3] = children;
+        $[4] = dimColor;
+        $[5] = t1;
+        $[6] = t2;
+    }
+    else {
+        t1 = $[5];
+        t2 = $[6];
+    }
+    if (t2 !== Symbol.for("react.early_return_sentinel")) {
+        return t2;
+    }
+    const content = t1;
+    let t3;
+    if ($[9] !== content || $[10] !== dimColor) {
+        t3 = dimColor ? _jsx(Text, { dim: true, children: content }) : _jsx(Text, { children: content });
+        $[9] = content;
+        $[10] = dimColor;
+        $[11] = t3;
+    }
+    else {
+        t3 = $[11];
+    }
+    return t3;
+});
+/**
+ * Parse an ANSI string into spans using the termio parser.
+ */
+function parseToSpans(input) {
+    const parser = new Parser();
+    const actions = parser.feed(input);
+    const spans = [];
+    let currentHyperlink;
+    for (const action of actions) {
+        if (action.type === 'link') {
+            if (action.action.type === 'start') {
+                currentHyperlink = action.action.url;
+            }
+            else {
+                currentHyperlink = 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;
+            }
+            // Try to merge with previous span if props match
+            const lastSpan = spans[spans.length - 1];
+            if (lastSpan && propsEqual(lastSpan.props, props)) {
+                lastSpan.text += text;
+            }
+            else {
+                spans.push({
+                    text,
+                    props
+                });
+            }
+        }
+    }
+    return spans;
+}
+/**
+ * Convert termio's TextStyle to SpanProps.
+ */
+function textStyleToSpanProps(style) {
+    const props = {};
+    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 fgColor = colorToString(style.fg);
+    if (fgColor)
+        props.color = fgColor;
+    const bgColor = colorToString(style.bg);
+    if (bgColor)
+        props.backgroundColor = bgColor;
+    return props;
+}
+// Map termio named colors to the ansi: format
+const NAMED_COLOR_MAP = {
+    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'
+};
+/**
+ * Convert termio's Color to the string format used by Ink.
+ */
+function colorToString(color) {
+    switch (color.type) {
+        case 'named':
+            return NAMED_COLOR_MAP[color.name];
+        case 'indexed':
+            return `ansi256(${color.index})`;
+        case 'rgb':
+            return `rgb(${color.r},${color.g},${color.b})`;
+        case 'default':
+            return undefined;
+    }
+}
+/**
+ * Check if two SpanProps are equal for merging.
+ */
+function propsEqual(a, b) {
+    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) {
+    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) {
+    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;
+}
+// Wrapper component that handles bold/dim mutual exclusivity for Text
+function StyledText(t0) {
+    const $ = _c(14);
+    let bold;
+    let children;
+    let dim;
+    let rest;
+    if ($[0] !== t0) {
+        ({
+            bold,
+            dim,
+            children,
+            ...rest
+        } = t0);
+        $[0] = t0;
+        $[1] = bold;
+        $[2] = children;
+        $[3] = dim;
+        $[4] = rest;
+    }
+    else {
+        bold = $[1];
+        children = $[2];
+        dim = $[3];
+        rest = $[4];
+    }
+    if (dim) {
+        let t1;
+        if ($[5] !== children || $[6] !== rest) {
+            t1 = _jsx(Text, { ...rest, dim: true, children: children });
+            $[5] = children;
+            $[6] = rest;
+            $[7] = t1;
+        }
+        else {
+            t1 = $[7];
+        }
+        return t1;
+    }
+    if (bold) {
+        let t1;
+        if ($[8] !== children || $[9] !== rest) {
+            t1 = _jsx(Text, { ...rest, bold: true, children: children });
+            $[8] = children;
+            $[9] = rest;
+            $[10] = t1;
+        }
+        else {
+            t1 = $[10];
+        }
+        return t1;
+    }
+    let t1;
+    if ($[11] !== children || $[12] !== rest) {
+        t1 = _jsx(Text, { ...rest, children: children });
+        $[11] = children;
+        $[12] = rest;
+        $[13] = t1;
+    }
+    else {
+        t1 = $[13];
+    }
+    return t1;
+}

package/lib/types/ink/bidi.d.ts

@@ -0,0 +1,18 @@
+type ClusteredChar = {
+    value: string;
+    width: number;
+    styleId: number;
+    hyperlink: string | undefined;
+};
+/**
+ * Reorder an array of ClusteredChars from logical order to visual order
+ * using the Unicode Bidi Algorithm. Active on terminals that lack native
+ * bidi support (Windows Terminal, conhost, WSL).
+ *
+ * Returns the same array on bidi-capable terminals (no-op).
+ * @param characters - clustered chars in logical order.
+ * @returns the characters in visual order, or the same array when no reordering applies.
+ */
+export declare function reorderBidi(characters: ClusteredChar[]): ClusteredChar[];
+export {};
+//# sourceMappingURL=bidi.d.ts.map

package/lib/types/ink/bidi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bidi.d.ts","sourceRoot":"","sources":["../../../src/ink/bidi.ts"],"names":[],"mappings":"AAkBA,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;CAC9B,CAAA;AAsBD;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE,CAoDxE"}

package/lib/types/ink/bidi.js

@@ -0,0 +1,119 @@
+/**
+ * Bidirectional text reordering for terminal rendering.
+ *
+ * Terminals on Windows do not implement the Unicode Bidi Algorithm,
+ * so RTL text (Hebrew, Arabic, etc.) appears reversed. This module
+ * applies the bidi algorithm to reorder ClusteredChar arrays from
+ * logical order to visual order before Ink's LTR cell placement loop.
+ *
+ * On macOS terminals (Terminal.app, iTerm2) bidi works natively.
+ * Windows Terminal (including WSL) does not implement bidi
+ * (https://github.com/microsoft/terminal/issues/538).
+ *
+ * Detection: Windows Terminal sets WT_SESSION; native Windows cmd/conhost
+ * also lacks bidi. We enable bidi reordering when running on Windows or
+ * inside Windows Terminal (covers WSL).
+ */
+import bidiFactory from 'bidi-js';
+let bidiInstance;
+let needsSoftwareBidi;
+function needsBidi() {
+    if (needsSoftwareBidi === undefined) {
+        needsSoftwareBidi =
+            process.platform === 'win32' ||
+                typeof process.env['WT_SESSION'] === 'string' || // WSL in Windows Terminal
+                process.env['TERM_PROGRAM'] === 'vscode'; // VS Code integrated terminal (xterm.js)
+    }
+    return needsSoftwareBidi;
+}
+function getBidi() {
+    if (!bidiInstance) {
+        bidiInstance = bidiFactory();
+    }
+    return bidiInstance;
+}
+/**
+ * Reorder an array of ClusteredChars from logical order to visual order
+ * using the Unicode Bidi Algorithm. Active on terminals that lack native
+ * bidi support (Windows Terminal, conhost, WSL).
+ *
+ * Returns the same array on bidi-capable terminals (no-op).
+ * @param characters - clustered chars in logical order.
+ * @returns the characters in visual order, or the same array when no reordering applies.
+ */
+export function reorderBidi(characters) {
+    if (!needsBidi() || characters.length === 0) {
+        return characters;
+    }
+    // Build a plain string from the clustered chars to run through bidi
+    const plainText = characters.map(c => c.value).join('');
+    // Check if there are any RTL characters — skip bidi if pure LTR
+    if (!hasRTLCharacters(plainText)) {
+        return characters;
+    }
+    const bidi = getBidi();
+    const { levels } = bidi.getEmbeddingLevels(plainText, 'auto');
+    // Map bidi levels back to ClusteredChar indices.
+    // Each ClusteredChar may be multiple code units in the joined string.
+    const charLevels = [];
+    let offset = 0;
+    for (let i = 0; i < characters.length; i++) {
+        charLevels.push(levels[offset]);
+        offset += characters[i].value.length;
+    }
+    // Get reorder segments from bidi-js, but we need to work at the
+    // ClusteredChar level, not the string level. We'll implement the
+    // standard bidi reordering: find the max level, then for each level
+    // from max down to 1, reverse all contiguous runs >= that level.
+    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) {
+                // Find the end of this run
+                let j = i + 1;
+                while (j < reordered.length && charLevels[j] >= level) {
+                    j++;
+                }
+                // Reverse the run in both arrays
+                reverseRange(reordered, i, j - 1);
+                reverseRangeNumbers(charLevels, i, j - 1);
+                i = j;
+            }
+            else {
+                i++;
+            }
+        }
+    }
+    return reordered;
+}
+function reverseRange(arr, start, end) {
+    while (start < end) {
+        const temp = arr[start];
+        arr[start] = arr[end];
+        arr[end] = temp;
+        start++;
+        end--;
+    }
+}
+function reverseRangeNumbers(arr, start, end) {
+    while (start < end) {
+        const temp = arr[start];
+        arr[start] = arr[end];
+        arr[end] = temp;
+        start++;
+        end--;
+    }
+}
+/**
+ * Quick check for RTL characters (Hebrew, Arabic, and related scripts).
+ * Avoids running the full bidi algorithm on pure-LTR text.
+ */
+function hasRTLCharacters(text) {
+    // Hebrew: U+0590-U+05FF, U+FB1D-U+FB4F
+    // Arabic: U+0600-U+06FF, U+0750-U+077F, U+08A0-U+08FF, U+FB50-U+FDFF, U+FE70-U+FEFF
+    // Thaana: U+0780-U+07BF
+    // Syriac: U+0700-U+074F
+    return /[\u0590-\u05FF\uFB1D-\uFB4F\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF\u0780-\u07BF\u0700-\u074F]/u.test(text);
+}

package/lib/types/ink/clearTerminal.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Cross-platform terminal clearing with scrollback support.
+ * Detects modern terminals that support ESC[3J for clearing scrollback.
+ */
+/**
+ * Returns the ANSI escape sequence to blank the screen while PRESERVING the
+ * scrollback (user-scrolled history).
+ *
+ * NOT using ESC[2J / ESC[3J: inside a DEC 2026 sync-output block (BSU/ESU)
+ * Windows Terminal snaps the viewport back to the top on those sequences
+ * (claude-code#35580), and dsh-tui's full resets run inside sync blocks.
+ * Scrolling the content far above the viewport (CSI <n> S) blanks the
+ * screen the same way — everything is pushed into the scrollback, the
+ * viewport shows empty rows — without moving the viewport.
+ * @returns the escape sequence that pushes content into the scrollback and homes the cursor.
+ */
+export declare function getClearTerminalSequence(rows?: number): string;
+/**
+ * Clears the terminal screen. On supported terminals, also clears scrollback.
+ */
+export declare const clearTerminal: string;
+//# sourceMappingURL=clearTerminal.d.ts.map

package/lib/types/ink/clearTerminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clearTerminal.d.ts","sourceRoot":"","sources":["../../../src/ink/clearTerminal.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAmDH;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAiB9D;AAED;;GAEG;AACH,eAAO,MAAM,aAAa,QAA6B,CAAA"}

package/lib/types/ink/clearTerminal.js

@@ -0,0 +1,72 @@
+/**
+ * Cross-platform terminal clearing with scrollback support.
+ * Detects modern terminals that support ESC[3J for clearing scrollback.
+ */
+import { CURSOR_HOME, csi, SGR_RESET, scrollUp, } from './termio/csi.js';
+// HVP (Horizontal Vertical Position) - legacy Windows cursor home
+const CURSOR_HOME_WINDOWS = csi(0, 'f');
+function isWindowsTerminal() {
+    return process.platform === 'win32' && !!process.env.WT_SESSION;
+}
+function isMintty() {
+    // mintty 3.1.5+ sets TERM_PROGRAM to 'mintty'
+    if (process.env.TERM_PROGRAM === 'mintty') {
+        return true;
+    }
+    // GitBash/MSYS2/MINGW use mintty and set MSYSTEM
+    if (process.platform === 'win32' && process.env.MSYSTEM) {
+        return true;
+    }
+    return false;
+}
+function isModernWindowsTerminal() {
+    // Windows Terminal sets WT_SESSION environment variable
+    if (isWindowsTerminal()) {
+        return true;
+    }
+    // VS Code integrated terminal on Windows with ConPTY support
+    if (process.platform === 'win32' &&
+        process.env.TERM_PROGRAM === 'vscode' &&
+        process.env.TERM_PROGRAM_VERSION) {
+        return true;
+    }
+    // mintty (GitBash/MSYS2/Cygwin) supports modern escape sequences
+    if (isMintty()) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Returns the ANSI escape sequence to blank the screen while PRESERVING the
+ * scrollback (user-scrolled history).
+ *
+ * NOT using ESC[2J / ESC[3J: inside a DEC 2026 sync-output block (BSU/ESU)
+ * Windows Terminal snaps the viewport back to the top on those sequences
+ * (claude-code#35580), and dsh-tui's full resets run inside sync blocks.
+ * Scrolling the content far above the viewport (CSI <n> S) blanks the
+ * screen the same way — everything is pushed into the scrollback, the
+ * viewport shows empty rows — without moving the viewport.
+ * @returns the escape sequence that pushes content into the scrollback and homes the cursor.
+ */
+export function getClearTerminalSequence(rows) {
+    // SGR_RESET first: CSI S fills the scrolled-in rows with the CURRENT
+    // background color (BCE). Frame-end resets normally guarantee SGR=none,
+    // but a truncated frame (dropped bytes, interrupted write) can leave a
+    // colored background active — without the reset, this scroll floods the
+    // blanked viewport with that color (seen in the wild as a full-screen
+    // red wash, issue #10).
+    //
+    // Scroll by ONE viewport height, not a huge constant: blanking the screen
+    // only needs the visible rows pushed out. The former scrollUp(10000)
+    // overshot the terminal's finite scrollback capacity (Windows Terminal
+    // defaults to 9001 lines) and evicted the user's ENTIRE scroll history,
+    // replacing it with blank rows — the opposite of the "preserving the
+    // scrollback" intent documented above. xterm.js-family terminals splice
+    // on CSI S, so the overshoot also cost O(10000) buffer operations there.
+    const n = rows && rows > 0 ? rows : (process.stdout.rows ?? 80);
+    return SGR_RESET + scrollUp(n) + CURSOR_HOME;
+}
+/**
+ * Clears the terminal screen. On supported terminals, also clears scrollback.
+ */
+export const clearTerminal = getClearTerminalSequence();

package/lib/types/ink/colorize.d.ts

@@ -0,0 +1,33 @@
+import type { Color, TextStyles } from './styles.js';
+/** Whether chalk's color level was boosted to 3 for xterm.js terminals. */
+export declare const CHALK_BOOSTED_FOR_XTERMJS: boolean;
+/** Whether chalk's color level was clamped to 2 for tmux passthrough. */
+export declare const CHALK_CLAMPED_FOR_TMUX: boolean;
+/** Which part of a cell a color applies to: text or background. */
+export type ColorType = 'foreground' | 'background';
+/**
+ * Apply a raw color value to a string using chalk.
+ * @param str - the text to color.
+ * @param color - the raw color value (ansi:*, hex, ansi256, or rgb); empty or unparsable values leave `str` unchanged.
+ * @param type - whether the color applies to foreground or background.
+ * @returns `str` wrapped in the chalk color sequence, or `str` unchanged when no color applies.
+ */
+export declare const colorize: (str: string, color: string | undefined, type: ColorType) => string;
+/**
+ * Apply TextStyles to a string using chalk.
+ * This is the inverse of parsing ANSI codes - we generate them from structured styles.
+ * Theme resolution happens at component layer, not here.
+ * @param text - the text to style.
+ * @param styles - the structured styles to apply.
+ * @returns `text` wrapped in the chalk sequences for the enabled styles.
+ */
+export declare function applyTextStyles(text: string, styles: TextStyles): string;
+/**
+ * Apply a raw color value to text.
+ * Theme resolution should happen at component layer, not here.
+ * @param text - the text to color.
+ * @param color - the raw foreground color value; undefined or empty leaves `text` unchanged.
+ * @returns `text` wrapped in the foreground color sequence.
+ */
+export declare function applyColor(text: string, color: Color | undefined): string;
+//# sourceMappingURL=colorize.d.ts.map

package/lib/types/ink/colorize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorize.d.ts","sourceRoot":"","sources":["../../../src/ink/colorize.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AA2DpD,2EAA2E;AAC3E,eAAO,MAAM,yBAAyB,SAA8B,CAAA;AACpE,yEAAyE;AACzE,eAAO,MAAM,sBAAsB,SAA2B,CAAA;AAE9D,mEAAmE;AACnE,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG,YAAY,CAAA;AAKnD;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GACnB,KAAK,MAAM,EACX,OAAO,MAAM,GAAG,SAAS,EACzB,MAAM,SAAS,KACd,MAgGF,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,MAAM,CA4CxE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,MAAM,CAKzE"}