zames_pro 2.49.1 → 2.49.3

package/dist/input.js

@@ -93,7 +93,12 @@ export function visRows(s, cols) {
     const len = visLen(s);
     return Math.max(1, Math.ceil(len / width));
 }
-// Visible length of a line without ANSI sequences.
+// Visible length of a line without ANSI sequences. WIDE characters (emoji,
+// CJK) count as 2 columns — a plain code-point count made the status-line
+// arithmetic (right-align, wrapping, block erase) disagree with the real
+// screen, so a status containing an emoji/CJK could wrap past the edge and
+// make the block erase miss (status "stacking"). Combining marks and the
+// zero-width joiner/space/variation selectors count as 0.
 export function visLen(s) {
     s = String(s);
     let n = 0;
@@ -109,11 +114,48 @@ export function visLen(s) {
             }
             continue;
         }
-        n++;
-        i++;
+        const cp = s.codePointAt(i);
+        n += charWidth(cp);
+        i += cp > 0xffff ? 2 : 1;
     }
     return n;
 }
+// Display width of one code point in columns (0, 1 or 2). Based on the
+// conventional wcwidth ranges — good enough for terminal layout, and it makes
+// the emoji used in the status line (🧠🌐) count as 2, while math symbols like
+// ⧗ (U+29D7) stay 1, matching a real terminal.
+export function charWidth(cp) {
+    // Zero width: combining marks, ZWJ/ZWNJ, variation selectors.
+    if (cp === 0x200b ||
+        cp === 0x200c ||
+        cp === 0x200d ||
+        (cp >= 0x0300 && cp <= 0x036f) ||
+        (cp >= 0x1ab0 && cp <= 0x1aff) ||
+        (cp >= 0x1dc0 && cp <= 0x1dff) ||
+        (cp >= 0x20d0 && cp <= 0x20ff) ||
+        (cp >= 0xfe00 && cp <= 0xfe0f) ||
+        (cp >= 0xfe20 && cp <= 0xfe2f)) {
+        return 0;
+    }
+    // Wide: CJK, Hangul, fullwidth forms, emoji.
+    if ((cp >= 0x1100 && cp <= 0x115f) ||
+        (cp >= 0x2e80 && cp <= 0x303e) ||
+        (cp >= 0x3041 && cp <= 0x33ff) ||
+        (cp >= 0x3400 && cp <= 0x4dbf) ||
+        (cp >= 0x4e00 && cp <= 0x9fff) ||
+        (cp >= 0xa000 && cp <= 0xa4cf) ||
+        (cp >= 0xac00 && cp <= 0xd7a3) ||
+        (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe30 && cp <= 0xfe4f) ||
+        (cp >= 0xff00 && cp <= 0xff60) ||
+        (cp >= 0xffe0 && cp <= 0xffe6) ||
+        (cp >= 0x1f000 && cp <= 0x1f02f) ||
+        (cp >= 0x1f300 && cp <= 0x1faff) ||
+        (cp >= 0x20000 && cp <= 0x3fffd)) {
+        return 2;
+    }
+    return 1;
+}
 export function layoutInput(promptStr, buf, cursor, cols) {
     const width = Math.max(20, Number(cols) || 80);
     const promptW = visLen(promptStr);
@@ -128,21 +170,29 @@ export function layoutInput(promptStr, buf, cursor, cols) {
         const avail = Math.max(1, width - promptW);
         const start = i;
         // Build the next visual line. First we take as many
-        // characters as fit (count < avail). If we hit the width
+        // characters as fit (columns < avail). If we hit the width
         // and the next character is not the end of the line, we roll back to the
         // last space so we don't split a word in the middle (word-wrap).
+        // Wrapping and the cursor column are measured in COLUMNS (charWidth),
+        // not code points — otherwise a CJK/emoji input would overflow the row
+        // and put the cursor on the wrong cell.
         let text = '';
-        let count = 0;
-        let lastSpace = -1; // index of the space in text (by Array.from)
-        while (i < chars.length && chars[i] !== NL && count < avail) {
+        let widthUsed = 0;
+        let charIdx = 0;
+        let lastSpace = -1; // char index of the space within text
+        while (i < chars.length && chars[i] !== NL) {
+            const w = charWidth(chars[i].codePointAt(0));
+            if (widthUsed + w > avail)
+                break;
             if (chars[i] === ' ')
-                lastSpace = count;
+                lastSpace = charIdx;
             text += chars[i];
             i++;
-            count++;
+            charIdx++;
+            widthUsed += w;
         }
         const atLineEnd = i >= chars.length || chars[i] === NL;
-        if (!atLineEnd && count >= avail && lastSpace > 0) {
+        if (!atLineEnd && widthUsed >= avail && lastSpace > 0) {
             // Move the "tail" of the line to the next visual line.
             const textChars = Array.from(text);
             const tailLen = textChars.length - lastSpace;
@@ -162,7 +212,8 @@ export function layoutInput(promptStr, buf, cursor, cols) {
     let cursorCol = promptW;
     for (let r = 0; r < rows.length; r++) {
         const row = rows[r];
-        const len = Array.from(row.text).length;
+        const rowChars = Array.from(row.text);
+        const len = rowChars.length;
         const from = row.start;
         const to = row.start + len;
         if (cur >= from && cur <= to) {
@@ -170,7 +221,12 @@ export function layoutInput(promptStr, buf, cursor, cols) {
             if (cur === to && next && next.start === to)
                 continue;
             cursorRow = r;
-            cursorCol = promptW + (cur - from);
+            // Cursor column in COLUMNS (wide chars count as 2).
+            let w = 0;
+            for (let k = 0; k < cur - from; k++) {
+                w += charWidth(rowChars[k].codePointAt(0));
+            }
+            cursorCol = promptW + w;
             break;
         }
     }
@@ -683,11 +739,19 @@ export class LineEditor {
     // status stays on screen, only the input area is redrawn. This removes the
     // full-screen flicker on terminals like Tabby, where erasing the whole block
     // on every character made the display blink.
-    _eraseInputOnly(inputRows) {
+    //
+    // `cursorRowInInput` is the cursor's row WITHIN the input area (0-based) as
+    // it is currently on screen: we move up exactly that many rows to the input's
+    // TOP and clear downward (ESC[J), which also wipes the hint lines below the
+    // input. Passing the input's full HEIGHT here (an earlier version did)
+    // overshot by `cursorRow` rows whenever the cursor was not on the last visual
+    // line, so every keystroke redrew the block one row higher — the input line
+    // visibly climbed from the bottom to the top of the screen.
+    _eraseInputOnly(cursorRowInInput) {
         if (!this.rendered)
             return;
         const rows = process.stdout.rows || 24;
-        const up = Math.min(Math.max(0, inputRows - 1), Math.max(0, rows - 1));
+        const up = Math.min(Math.max(0, cursorRowInInput), Math.max(0, rows - 1));
         if (up > 0)
             process.stdout.write(ESC + '[' + up + 'A');
         process.stdout.write(CR + ESC + '[J');
@@ -777,13 +841,14 @@ export class LineEditor {
         if (statusUnchanged) {
             // Count the real input rows via layout (wrapping aware).
             const layOnly = layoutInput(this.promptStr, this.buf, this.cursor, cols);
-            const inputLineRows = layOnly.rows.length;
             const suggOnly = this._suggestions();
             const shownOnly = suggOnly.slice(0, 8);
             const linesBelowOnly = shownOnly.length
                 ? shownOnly.length + (suggOnly.length > shownOnly.length ? 1 : 0)
                 : 0;
-            this._eraseInputOnly(inputLineRows + linesBelowOnly);
+            // Move up to the INPUT top using the OLD cursor row (the position that is
+            // on screen right now), never the input's height.
+            this._eraseInputOnly(this.cursorRowFromTop - this._statusTop);
             let outOnly = '';
             outOnly += layOnly.rows.map((r) => r.prefix + r.text).join(NL);
             if (shownOnly.length) {
@@ -885,14 +950,14 @@ export class LineEditor {
         }
         const cols = process.stdout.columns || 80;
         const lay = layoutInput(this.promptStr, this.buf, this.cursor, cols);
-        const inputRows = lay.rows.length;
         const sugg = this._suggestions();
         const shown = sugg.slice(0, 8);
         this._suggestCount = shown.length;
         const linesBelow = shown.length
             ? shown.length + (sugg.length > shown.length ? 1 : 0)
             : 0;
-        this._eraseInputOnly(inputRows + linesBelow);
+        // Move up to the INPUT top using the OLD cursor row (on screen right now).
+        this._eraseInputOnly(this.cursorRowFromTop - this._statusTop);
         let out = lay.rows.map((r) => r.prefix + r.text).join(NL);
         if (shown.length) {
             const maxName = Math.max(...shown.map((c) => c.name.length));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.49.1",
+  "version": "2.49.3",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {