dsh-ssh-tui 0.7.4 → 0.8.1

package/lib/term-text.js

@@ -7,6 +7,7 @@
 import { t } from './i18n/index.js';
 import { downgradeSgr } from './color-depth.js';
 import { asciiFallbackEnabled } from './platform.js';
+import { activeTheme, themeExtraToken } from './theme.js';
 /**
  * Codex-style compact elapsed: `0s`, `1m 05s`, `1h 01m 01s`.
  * Used by the workspace wait card while the model has not streamed yet.
@@ -296,9 +297,246 @@ export function mapAsciiChrome(text) {
  * Overflow into the input box is handled by clipping/padding painted rows to
  * the measured column count, not by inflating glyph width.
  */
+/**
+ * East-Asian Ambiguous families that a CJK-configured terminal draws two cells
+ * wide, and that this TUI therefore budgets two cells for.
+ *
+ * The reported bug was `①`-`⑩`: the model writes them, the terminal draws them
+ * from a CJK font in the space of two cells, and every row holding one came out
+ * a cell short — the same class of failure as the emoji glyphs above, with one
+ * important difference. Emoji can be *pinned* ({@link pinEmojiCells} asks for the
+ * text presentation and reserves the second cell) because they have variation
+ * selectors; these characters have none, so the only lever is to budget what the
+ * terminal will actually spend.
+ *
+ * What is deliberately **not** in this table matters as much. Box drawing (`─`),
+ * geometric ornaments (`●`, `▸`) and the chrome glyphs `❯` / `✓` are ambiguous
+ * too, but they were measured against a real terminal in the earlier emoji pass
+ * and they come from the monospace font at one cell; counting them as two is
+ * what once painted half-width rules and parked the cursor past the text. They
+ * stay one cell until a measurement says otherwise.
+ */
+const AMBIGUOUS_WIDE_RANGES = [
+    [0x2460, 0x24ff], // Enclosed Alphanumerics: ① ⑩ ⑳ ⑴ ⒈ ⓐ ⓿
+    [0x2776, 0x2793], // Dingbat circled digits: ❶ ➀ ➊ ➓
+    [0x2160, 0x217f], // Roman numerals: Ⅰ Ⅱ ⅰ ⅻ
+    [0x1f100, 0x1f1ff], // Enclosed Alphanumeric Supplement, incl. regional indicators
+    [0x1f200, 0x1f2ff], // Enclosed Ideographic Supplement
+    // Punctuation that a CJK font sets **full width**, and that a Chinese
+    // transcript is full of: an em dash, an ellipsis and curly quotes are 全角 in
+    // GB2312/GBK. A real session carries `—` tens of thousands of times, so
+    // budgeting one cell for it is not a corner case — it is every line.
+    [0x00b7, 0x00b7], // · middle dot
+    [0x2013, 0x2014], // – — dashes
+    [0x2018, 0x201d], // ‘ ’ “ ” quotes
+    [0x2022, 0x2022], // • bullet
+    [0x2025, 0x2026], // ‥ … ellipsis
+    [0x2039, 0x203a], // ‹ › guillemets
+];
+/** Cached decision for {@link ambiguousWidthIsTwo}, keyed on the inputs. */
+let ambiguousCache;
+/**
+ * What a measurement of the real terminal said, when there was one.
+ *
+ * The locale is only a guess about which font the terminal is configured with,
+ * and a guess is what produced three rounds of "① is misaligned" reports: the
+ * terminal either advances two cells for it or it does not, and that is
+ * measurable (`CSI 6n` after the glyph). The launcher measures once at boot, in
+ * the process that owns the terminal, and sets this. `undefined` means nobody
+ * measured — a pipe, a dumb terminal, or a launch that never got that far — and
+ * the locale decides as before.
+ */
+let ambiguousMeasured;
+/**
+ * Whether the second cell must be *reserved* with a space.
+ *
+ * An ambiguous glyph can be drawn wider than the single cell it advances — the
+ * same failure the emoji symbols have, and the one behind "`①` collides with the
+ * character after it". Emoji can be pinned by asking for the text presentation
+ * with VS15; `①` has no variation sequence, so the only half of that trick
+ * available is the reserving space: print the glyph, then a space, and the next
+ * character starts on a clean cell while the layout still spends two.
+ *
+ * Set from the measurement, because the two cases need opposite treatment:
+ * a terminal that advances two cells spends them itself (`wide`), while one that
+ * advances one cell needs the space (`reserve`).
+ */
+let ambiguousReserve;
+/**
+ * The resolved policy, cached.
+ *
+ * This used to be worked out *inside* `displayWidth`'s per-character loop, which
+ * read `process.env` and ran regexes for every character of every painted line —
+ * a profile of a 2000-row frame put ~75% of the samples there, and it is why
+ * rendering in a long session felt slow. The policy cannot change during a frame,
+ * so it is resolved once and read as plain booleans afterwards; the setters below
+ * and `ambiguousPolicy()`'s own cheap key check are what invalidate it.
+ */
+let ambiguousPolicyCache;
+/** The three inputs the policy depends on, as one cheap-to-compare string. */
+function ambiguousPolicyKey(env, onTerminal) {
+    return `${env.DSH_TUI_AMBIGUOUS_WIDTH ?? ''}|${env.DSH_TUI_AMBIGUOUS_RESERVE ?? ''}|`
+        + `${env.LC_ALL ?? ''}|${env.LC_CTYPE ?? ''}|${env.LANG ?? ''}|`
+        + `${onTerminal ? 'tty' : 'pipe'}|${String(ambiguousMeasured)}|${String(ambiguousReserve)}`;
+}
+/**
+ * Resolve the ambiguous-glyph policy for this process.
+ *
+ * Cheap enough to call once per line (it compares one string) and far too
+ * expensive to call per character, which is the distinction that matters.
+ * @param env - the environment to read.
+ * @param onTerminal - whether the output is a terminal at all.
+ * @returns whether the glyphs are two cells wide, and whether the second cell is
+ *   ours to reserve.
+ */
+export function ambiguousPolicy(env = process.env, onTerminal = process.stdout?.isTTY === true) {
+    const key = ambiguousPolicyKey(env, onTerminal);
+    const cached = ambiguousPolicyCache;
+    if (cached !== undefined && cached.key === key)
+        return cached;
+    const override = String(env.DSH_TUI_AMBIGUOUS_WIDTH ?? '').trim();
+    const reserveOverride = String(env.DSH_TUI_AMBIGUOUS_RESERVE ?? '').trim();
+    const locale = `${env.LC_ALL ?? ''} ${env.LC_CTYPE ?? ''} ${env.LANG ?? ''}`.toLowerCase();
+    const localeIsCjk = /(?:^|[^a-z])(?:zh|ja|ko)[_@.-]/u.test(locale) || /(?:^|\s)(?:zh|ja|ko)(?:\s|$)/u.test(locale);
+    let wide;
+    if (override === '1')
+        wide = false;
+    else if (override === '2')
+        wide = true;
+    else if (ambiguousMeasured !== undefined)
+        wide = ambiguousMeasured;
+    else
+        wide = onTerminal && localeIsCjk;
+    // The reservation is only worth its space when the terminal advances one cell
+    // for a glyph it draws wider than a cell; a measurement is the evidence for it,
+    // and the environment is the manual override.
+    let reserve = ambiguousReserve ?? (reserveOverride === '1' || reserveOverride === 'true');
+    if (override === '1' || override === '2')
+        reserve = ambiguousReserve ?? false;
+    ambiguousPolicyCache = { key, wide, reserve };
+    return ambiguousPolicyCache;
+}
+/**
+ * The reserve setting from the environment, when a parent passed one.
+ *
+ * The Host cannot measure, so its launcher hands the verdict over in the
+ * environment alongside the advance: `DSH_TUI_AMBIGUOUS_WIDTH` says how many
+ * cells the terminal spends, `DSH_TUI_AMBIGUOUS_RESERVE` says whether the second
+ * one has to be spent by us. Reading it lazily keeps this module free of a
+ * startup order: the value is a property of the deployment, not of the call.
+ */
+function reserveFromEnv() {
+    const raw = String(process.env.DSH_TUI_AMBIGUOUS_RESERVE ?? '').trim();
+    return raw === '1' || raw === 'true';
+}
+/**
+ * Record what the terminal's own answer said about these glyphs.
+ *
+ * Called by the launcher after measuring; also the escape hatch for a caller
+ * that knows better than the locale (a relay that has already measured for its
+ * own accounting, or a test).
+ * @param wide - true when the terminal advances two cells, false for one, or
+ *   undefined to fall back to the locale.
+ */
+export function setAmbiguousWidthMeasured(wide) {
+    ambiguousMeasured = wide;
+    ambiguousPolicyCache = undefined;
+    // A terminal that advances one cell for a glyph drawn wider than a cell is
+    // exactly the collision case; reserve the second cell so the next character is
+    // not painted on top of it.
+    ambiguousReserve = wide === false;
+    ambiguousCache = undefined;
+}
+/**
+ * Force the reserve behaviour, for a caller that measured the same terminal for
+ * its own accounting (a relay) or a test.
+ * @param reserve - whether to spend a space after each ambiguous glyph.
+ */
+export function setAmbiguousWidthReserve(reserve) {
+    ambiguousReserve = reserve;
+    ambiguousPolicyCache = undefined;
+    ambiguousCache = undefined;
+}
+/** Whether the second cell is currently reserved with a space. */
+export function ambiguousWidthReserved() {
+    return ambiguousPolicy().reserve;
+}
+/**
+ * Whether one code point is in a family the ambiguous policy governs.
+ *
+ * A scan over a handful of pairs, cheap enough for the per-character path — which
+ * is why the policy booleans are resolved once per line and passed in, rather
+ * than looked up per character.
+ * @param cp - the code point.
+ * @returns true when the ambiguous table applies to it.
+ */
+function inAmbiguousRange(cp) {
+    for (const [start, end] of AMBIGUOUS_WIDE_RANGES) {
+        if (cp >= start && cp <= end)
+            return true;
+    }
+    return false;
+}
+/**
+ * Cells one character costs in this TUI's layout.
+ *
+ * The reserve case still costs two: the glyph advances one cell and the reserving
+ * space takes the next, so the layout must budget both or every row holding one
+ * comes up short. Non-ambiguous characters are unchanged.
+ * @param cp - the code point.
+ * @returns 0, 1 or 2 cells.
+ */
+export function ambiguousCellCost(cp) {
+    if (!inAmbiguousRange(cp))
+        return 0;
+    const policy = ambiguousPolicy();
+    return policy.reserve || policy.wide ? 2 : 1;
+}
+/** What the last measurement decided, for diagnostics and tests. */
+export function ambiguousWidthMeasured() {
+    return ambiguousMeasured;
+}
+/**
+ * Whether ambiguous glyphs in {@link AMBIGUOUS_WIDE_RANGES} are drawn two cells
+ * wide here.
+ *
+ * `DSH_TUI_AMBIGUOUS_WIDTH=1|2` answers outright. Otherwise the locale decides,
+ * and only when there really is a terminal: a zh/ja/ko locale means the terminal
+ * is very likely using a CJK font, where these glyphs are full width. The UI
+ * language is deliberately *not* consulted — a Chinese reader on a Western
+ * terminal has narrow glyphs, and typing in Chinese does not change the font
+ * metrics.
+ * @param env - the environment to read (tests pass their own).
+ * @param onTerminal - whether the output is a terminal at all; a pipe or a test
+ *   harness has no font metrics, so there the narrow default applies.
+ * @returns true when those glyphs should be budgeted two cells.
+ */
+export function ambiguousWidthIsTwo(env = process.env, onTerminal = process.stdout?.isTTY === true) {
+    return ambiguousPolicy(env, onTerminal).wide;
+}
 export function displayWidth(text) {
     let width = 0;
-    for (const char of mapAsciiChrome(text)) {
+    const measured = mapAsciiChrome(text);
+    // Resolved once per call rather than per character: this runs for every
+    // character of every painted line, and the old lookup read `process.env` and
+    // ran a regex each time (a profile of a 2000-row frame put ~75% of its samples
+    // there). Here it costs one string comparison for the whole line.
+    const policy = ambiguousPolicy();
+    for (let index = 0; index < measured.length;) {
+        const char = measured[index] ?? '';
+        if (char === '')
+            break;
+        // A reserved glyph plus our own space is ONE two-cell unit: the pin adds the
+        // space so the terminal spends the second cell, and counting it again here
+        // would make every padded row one cell short.
+        if (char !== ' ' && policy.reserve && inAmbiguousRange(char.codePointAt(0) ?? 0)) {
+            width += 2;
+            index += char.length;
+            if (measured[index] === ' ')
+                index += 1;
+            continue;
+        }
+        index += char.length;
         if (char === '\t') {
             // Tabs are expanded to spaces before rendering; keep the width
             // calculation consistent with `sanitizeTerminalText()`.
@@ -317,7 +555,10 @@ export function displayWidth(text) {
         if (cp <= 0x1f || (cp >= 0x7f && cp <= 0x9f)) {
             continue;
         }
-        const wide = (cp >= 0x1100 && cp <= 0x115f) ||
+        // NOTE: `index` has already advanced past this character above; the branches
+        // below only decide how many cells it cost.
+        const wide = ((policy.wide || policy.reserve) && inAmbiguousRange(cp)) ||
+            (cp >= 0x1100 && cp <= 0x115f) ||
             cp === 0x2329 || cp === 0x232a ||
             (cp >= 0x2e80 && cp <= 0xa4cf) ||
             (cp >= 0xac00 && cp <= 0xd7a3) ||
@@ -362,6 +603,7 @@ export function pinEmojiCells(text) {
     const mapped = mapAsciiChrome(text);
     if (mapped !== text)
         return mapped;
+    const reserveWide = ambiguousPolicy().reserve;
     let out = '';
     let index = 0;
     while (index < text.length) {
@@ -371,6 +613,15 @@ export function pinEmojiCells(text) {
         const char = String.fromCodePoint(cp);
         index += char.length;
         out += char;
+        // An ambiguous glyph on a terminal that advances it one cell while drawing it
+        // wider: reserve the second cell so the next character is not painted on top
+        // of it. Skipped when the glyph is already followed by a space (the run may
+        // have been pinned once and be repainted), so pinning stays idempotent.
+        if (reserveWide && inAmbiguousRange(cp)) {
+            if (!/^[ ]/u.test(text.slice(index)))
+                out += ' ';
+            continue;
+        }
         if (!EMOJI_SYMBOLS.has(cp) || EMOJI_PRESENTATION_SYMBOLS.has(cp))
             continue;
         const selector = text.codePointAt(index);
@@ -410,7 +661,10 @@ export function padAnsiToWidth(text, width) {
 }
 /** Visible width of an ANSI-styled line, ignoring CSI / OSC sequences. */
 export function visibleWidth(text) {
-    let used = 0;
+    // Strip the escapes, then ask the one width function: summing per character
+    // here would count a reserved glyph's space twice (see `displayWidth`), and
+    // two width notions in one renderer is how rows drift apart.
+    let plain = '';
     let index = 0;
     while (index < text.length) {
         if (text.charCodeAt(index) === 0x1b) {
@@ -421,10 +675,10 @@ export function visibleWidth(text) {
         if (cp === undefined)
             break;
         const char = String.fromCodePoint(cp);
-        used += displayWidth(char);
+        plain += char;
         index += char.length;
     }
-    return used;
+    return displayWidth(plain);
 }
 /** Advance past one ESC sequence starting at `index`. */
 export function skipAnsiSequence(text, index) {
@@ -848,27 +1102,30 @@ function wrapMarkdownSegments(segments, width, prefixSegments = []) {
     return lines.map(line => line.length === 0 ? [{ kind: 'text', text: '' }] : line);
 }
 function markdownSegmentCode(kind) {
+    const theme = activeTheme();
     switch (kind) {
         // Bright + bold so **span** still pops when the font has no heavy CJK weight.
-        case 'bold': return '1;97';
-        case 'italic': return '3;37';
-        case 'code': return '36';
-        case 'link': return '4;36';
-        case 'muted': return '2;37';
+        case 'bold': return themeExtraToken(theme, 'md-bold');
+        case 'italic': return themeExtraToken(theme, 'md-italic');
+        case 'code': return themeExtraToken(theme, 'md-code');
+        case 'link': return themeExtraToken(theme, 'md-link');
+        case 'muted': return themeExtraToken(theme, 'md-muted');
         default: return '';
     }
 }
 function markdownBaseCode(kind) {
+    const theme = activeTheme();
     switch (kind) {
-        case 'heading1': return '1;4;97';
-        case 'heading2': return '1;4;36';
-        case 'heading3': return '1;36';
-        case 'code': return '36';
-        case 'quote': return '3;37';
-        case 'rule': return '90';
-        // Body is normal white so inline bold/italic/code are not painted on
-        // already-bold text (CJK fonts often have only one weight).
-        default: return '37';
+        case 'heading1': return themeExtraToken(theme, 'md-h1');
+        case 'heading2': return themeExtraToken(theme, 'md-h2');
+        case 'heading3': return themeExtraToken(theme, 'md-h3');
+        case 'code': return themeExtraToken(theme, 'md-code');
+        case 'quote': return themeExtraToken(theme, 'md-quote');
+        case 'rule': return themeExtraToken(theme, 'md-rule');
+        // Body keeps the terminal's own foreground: freezing it to white was
+        // unreadable on a light background, and bold/italic runs carry their own
+        // emphasis (CJK fonts often have only one weight).
+        default: return '';
     }
 }
 function wrapHyperlink(label, href, hyperlinks) {
@@ -887,14 +1144,19 @@ function renderMarkdownBlockLine(block, color, hyperlinks) {
         return segments.map(segment => wrapHyperlink(segment.text, segment.href, hyperlinks)).join('');
     }
     const base = markdownBaseCode(block.base);
-    let out = `\x1b[${base}m`;
+    // An empty base means "the terminal's own foreground", and opening with
+    // `\x1b[m` would emit a reset the row does not need — on a slow link that is
+    // one wasted escape per line, and it makes the transcript harder to read in a
+    // log. So the base is only emitted when the palette actually asks for it.
+    const open = base === '' ? '' : `\x1b[${base}m`;
+    let out = open;
     for (const segment of segments) {
         const code = markdownSegmentCode(segment.kind);
         const body = code === ''
             ? segment.text
             // SGR 0 first: restoring only the base codes does not clear italic,
             // underline, or bold, so those attributes would leak into later spans.
-            : `\x1b[${code}m${segment.text}\x1b[0m\x1b[${base}m`;
+            : `\x1b[${code}m${segment.text}\x1b[0m${open}`;
         out += wrapHyperlink(body, segment.href, hyperlinks);
     }
     return `${out}\x1b[0m`;
@@ -1150,6 +1412,8 @@ function backwardSliceByWidth(text, end, maxWidth) {
  * caret in the middle of later text. Fold the *current line* (between the
  * surrounding newlines) and keep `\n` out of the visible slice.
  */
+/** The character that marks a folded edge of the input row. */
+const FOLD_MARKER = '…';
 export function foldInputView(input, cursor, maxWidth) {
     const width = Math.max(1, maxWidth);
     const safeCursor = Math.max(0, Math.min(cursor, input.length));
@@ -1168,16 +1432,16 @@ export function foldInputView(input, cursor, maxWidth) {
         // One-row fold: keep a blank cell for the caret when the line fills
         // the row, otherwise CSI lands on the last glyph.
         if (cursorOffset >= width && width > 1) {
-            let budget = width - 1;
+            let budget = Math.max(1, width - 1);
             const probe = backwardSliceByWidth(line, lineCursor, budget);
             const left = probe.start > 0;
             if (left)
-                budget = Math.max(1, width - 2);
+                budget = Math.max(1, width - displayWidth(FOLD_MARKER) - 1);
             const clipped = backwardSliceByWidth(line, lineCursor, budget);
             const beforeText = line.slice(clipped.start, lineCursor);
             return {
-                text: `${left ? '…' : ''}${beforeText}`,
-                cursorOffset: (left ? 1 : 0) + displayWidth(beforeText),
+                text: `${left ? FOLD_MARKER : ''}${beforeText}`,
+                cursorOffset: (left ? displayWidth(FOLD_MARKER) : 0) + displayWidth(beforeText),
                 folded: true,
             };
         }
@@ -1187,7 +1451,11 @@ export function foldInputView(input, cursor, maxWidth) {
     const after = totalWidth - cursorOffset;
     const leftFolded = before > 0;
     const rightFolded = after > 0;
-    const markers = (leftFolded ? 1 : 0) + (rightFolded ? 1 : 0);
+    // The marker's own width, not a hardcoded cell: `…` is full width on a CJK
+    // terminal, and counting it as one made the folded row overrun its budget and
+    // put the caret a column off.
+    const markerWidth = displayWidth(FOLD_MARKER);
+    const markers = (leftFolded ? markerWidth : 0) + (rightFolded ? markerWidth : 0);
     // Leave one cell for the caret so it never sits on the last glyph
     // (DEC auto-margin would otherwise punch the caret through that cell).
     const available = Math.max(1, width - markers - 1);
@@ -1200,8 +1468,8 @@ export function foldInputView(input, cursor, maxWidth) {
     const afterSlice = forwardSliceByWidth(line.slice(lineCursor), afterBudget);
     const beforeText = line.slice(beforeSlice.start, lineCursor);
     return {
-        text: `${leftFolded ? '…' : ''}${beforeText}${afterSlice.text}${rightFolded ? '…' : ''}`,
-        cursorOffset: (leftFolded ? 1 : 0) + displayWidth(beforeText),
+        text: `${leftFolded ? FOLD_MARKER : ''}${beforeText}${afterSlice.text}${rightFolded ? FOLD_MARKER : ''}`,
+        cursorOffset: (leftFolded ? markerWidth : 0) + displayWidth(beforeText),
         folded: true,
     };
 }