zames_pro 2.50.0 → 2.50.1

package/dist/config-menu.js

@@ -9,11 +9,20 @@
 // types): the caller reads and writes values through callbacks. This makes the
 // menu easy to test and reuse.
 import { theme } from './theme.js';
+import { visLen } from './input.js';
 const ESC = String.fromCharCode(27);
 // Strip ANSI sequences to compute the visible length of a line.
 function stripAnsi(s) {
     return s.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '');
 }
+// Visible COLUMNS of a line (ANSI removed, wide chars counted as 2). Using the
+// code-point count made the block height disagree with the real screen on lines
+// with emoji/wide chars, so the erase moved to the wrong row and the config list
+// duplicated. A row that fills the terminal exactly also triggers autowrap on
+// some terminals, so we keep one column free here as the editor does.
+function visCols(s) {
+    return visLen(stripAnsi(s));
+}
 function displayValue(field, value, t) {
     if (value === undefined)
         return t('cfg.menu.default');
@@ -91,9 +100,11 @@ export function runConfigMenu(opts) {
         // (accounting for wrapping by terminal width), otherwise on narrow
         // terminals you get "garbage" from unerased tails.
         const cols = output.columns || 80;
+        // Reserve the last column like the editor does: a row that fills the
+        // terminal exactly can autowrap, which desyncs the block height.
+        const usable = Math.max(1, cols - 1);
         const rowsOf = (s) => {
-            const len = stripAnsi(s).length;
-            return Math.max(1, Math.ceil(len / Math.max(1, cols)));
+            return Math.max(1, Math.ceil(visCols(s) / usable));
         };
         if (lastRows > 0) {
             output.write(ESC + '[' + lastRows + 'A');

package/dist/input.js

@@ -157,7 +157,16 @@ export function charWidth(cp) {
     return 1;
 }
 export function layoutInput(promptStr, buf, cursor, cols) {
-    const width = Math.max(20, Number(cols) || 80);
+    // Reserve the LAST column. If a printed row reaches exactly `cols` columns,
+    // terminals with autowrap (Tabby, iTerm, Windows Terminal, xterm's default
+    // deferred wrap) either wrap the cursor to the next line or leave it in the
+    // last cell with a "pending wrap". In both cases the editor's row count
+    // disagrees with the real screen by one, so the cursor/erase arithmetic in
+    // `_renderInputOnly`/`_writeBlock` walks one row too far and the input line
+    // climbs. This was most visible in an EMPTY chat with a single long,
+    // space-less line (which fills the row exactly) and when moving the cursor
+    // with the arrow keys.
+    const width = Math.max(2, (Number(cols) || 80) - 1);
     const promptW = visLen(promptStr);
     const pad = ' '.repeat(promptW);
     const chars = Array.from(String(buf));
@@ -324,6 +333,13 @@ export class LineEditor {
     // keeping the status untouched removes that flicker. Cleared whenever the
     // status genuinely changes so the cache can never go stale.
     _lastStatusBlock;
+    // Rows occupied by the WHOLE block (status + input + hints) at the last
+    // write. When the block SHRINKS (the pause status disappears, the input
+    // unwraps) the erase leaves the cursor at the old block top; printing a
+    // shorter block then ends above the screen bottom, so the footer floated with
+    // blank rows below it. Padding the redraw with (prev - new) newlines pushes
+    // it back down to the bottom (see _padShrink).
+    _blockRows;
     _wasRaw;
     _onData;
     // On SIGWINCH we redraw the whole block so the layout follows the new
@@ -411,6 +427,7 @@ export class LineEditor {
         this._thinkBase = '';
         this._sendState = '';
         this._lastStatusBlock = '';
+        this._blockRows = 0;
         this._wasRaw = false;
         this._onData = (b) => this._handle(b);
         this._resizeTimer = null;
@@ -665,8 +682,20 @@ export class LineEditor {
         stdin.resume();
         process.stdout.write(ESC + '[?2004h');
         stdin.on('data', this._onData);
+        // `pause()` erased our block and handed the terminal to a foreign UI (the
+        // /config menu), which may leave the cursor ANYWHERE — after Esc the menu
+        // clears its block and parks the cursor at the TOP of the screen. Without
+        // re-pinning, the block would be redrawn up there and every later repaint
+        // would keep it glued to the top. Re-fill the viewport and forget the
+        // stale block height so the editor lands at the bottom again.
+        this._lastStatusBlock = '';
+        this._blockRows = 0;
+        // Start from a KNOWN row: the foreign UI may have parked the cursor
+        // anywhere (the /config menu leaves it near the top). From home, padding
+        // lands exactly on the last screen row.
+        process.stdout.write(ESC + '[H');
+        this._padToBottom();
         this._writeBlock();
-        this._render();
     }
     // Lock input while a long operation runs (chat resume/open, /new,
     // self-review). The line stays visible but text input and Enter are ignored,
@@ -865,6 +894,12 @@ export class LineEditor {
                         NL +
                             theme.dim('   ' + translate(this.locale)('editor.more', { n: hidden }));
             }
+            // The input may have UNWRAPPED (fewer rows than before) — push the block
+            // back to the bottom BEFORE the new content is printed (the padding is
+            // plain newlines at the top of the block, which scroll the screen).
+            const blockRowsOnly = top + layOnly.rows.length + linesBelowOnly;
+            this._padShrink(blockRowsOnly, this._blockRows);
+            this._blockRows = blockRowsOnly;
             process.stdout.write(outOnly);
             const upOnly = layOnly.rows.length - 1 - layOnly.cursorRow + linesBelowOnly;
             if (upOnly > 0)
@@ -899,13 +934,20 @@ export class LineEditor {
                     NL +
                         theme.dim('   ' + translate(this.locale)('editor.more', { n: hidden }));
         }
+        const linesBelow = shown.length
+            ? shown.length + (sugg.length > shown.length ? 1 : 0)
+            : 0;
+        // If the block SHRANK (the pause status went away, the input unwrapped),
+        // the erase left the cursor at the old block top; printing a shorter block
+        // would end above the screen bottom and the footer would float with blank
+        // rows below it. Padding with the difference pushes it back to the bottom.
+        const blockRows = top + lay.rows.length + linesBelow;
+        this._padShrink(blockRows, this._blockRows);
+        this._blockRows = blockRows;
         process.stdout.write(out);
         const lastRow = lay.rows.length - 1;
         // Move the cursor up: first to the input line within lay, then further by
         // the hint lines (if any) — the cursor must sit on the input.
-        const linesBelow = shown.length
-            ? shown.length + (sugg.length > shown.length ? 1 : 0)
-            : 0;
         const up = lastRow - lay.cursorRow + linesBelow;
         if (up > 0)
             process.stdout.write(ESC + '[' + up + 'A');
@@ -915,6 +957,19 @@ export class LineEditor {
         this.rendered = true;
         this.cursorRowFromTop = top + lay.cursorRow;
     }
+    // Push the redrawn block back down to the bottom when it got SHORTER than
+    // the previous one. `_eraseBlock`/`_eraseInputOnly` put the cursor at the old
+    // block top, so emitting (prev - next) newlines scrolls the screen just
+    // enough for the new, shorter block to end at the screen bottom again. See
+    // _blockRows.
+    _padShrink(nextRows, prevRows) {
+        if (prevRows <= nextRows)
+            return;
+        const rows = process.stdout.rows || 24;
+        const pad = Math.min(prevRows - nextRows, Math.max(0, rows - 1));
+        if (pad > 0)
+            process.stdout.write(NL.repeat(pad));
+    }
     // Public repaint hook: called when an external state that the status line
     // reads (e.g. the toggle icons) changed, so it can be redrawn immediately.
     refreshStatus() {
@@ -933,6 +988,10 @@ export class LineEditor {
         process.stdout.write(ESC + '[2J' + ESC + '[H');
         this.rendered = false;
         this._lastStatusBlock = '';
+        // We are about to re-pin the block to the bottom ourselves, so forget the
+        // previous block height — otherwise the shrink padding would add extra
+        // rows on top of the padding below.
+        this._blockRows = 0;
         // Re-pin the block to the bottom after the screen was cleared.
         this._padToBottom();
         this._writeBlock();
@@ -973,6 +1032,13 @@ export class LineEditor {
                     NL +
                         theme.dim('   ' + translate(this.locale)('editor.more', { n: hidden }));
         }
+        // A buffer change can UNWRAP the input (backspace on a wrapped line), so
+        // the block can get shorter here too — push it back to the bottom BEFORE
+        // the new content is printed (the padding is plain newlines at the top of
+        // the block, which scroll the screen).
+        const blockRows = this._statusTop + lay.rows.length + linesBelow;
+        this._padShrink(blockRows, this._blockRows);
+        this._blockRows = blockRows;
         process.stdout.write(out);
         const up = lay.rows.length - 1 - lay.cursorRow + linesBelow;
         if (up > 0)

package/package.json

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