zames_pro 2.50.0 → 2.50.2

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');
@@ -90,10 +99,17 @@ export function runConfigMenu(opts) {
         // Erase the previous block and print the new one. We count VISUAL lines
         // (accounting for wrapping by terminal width), otherwise on narrow
         // terminals you get "garbage" from unerased tails.
+        // Reserve the last column. A line whose visible width reaches exactly the
+        // terminal width hits the autowrap edge: depending on the terminal it
+        // either consumes two rows for the following `\n` or keeps a pending wrap,
+        // and in both cases a full-width divisor UNDERCOUNTS the block height — the
+        // erase then misses the tail and the config lines DUPLICATE on screen (the
+        // reported bug). Overcounting by one is a harmless blank row; undercounting
+        // is not, so we bias to the safe side here.
         const cols = output.columns || 80;
+        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

@@ -1,4 +1,4 @@
-import { theme } from './theme.js';
+import { theme, divider } from './theme.js';
 import { renderMarkdown } from './markdown.js';
 import { randomThinkingPhrase, stripEllipsis, DOTS, renderDots, } from './spinner.js';
 import { translate } from './i18n.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));
@@ -306,9 +315,6 @@ export class LineEditor {
     // True while the dot-animation timer is running. Lets sendPause() update
     // only the base text (remaining seconds) without restarting the timer.
     _animating;
-    // Whether the animated status shows the trailing "Esc — стоп" hint. Off
-    // while a tool runs (its process cannot be cancelled).
-    _showHint;
     _dotPhase;
     _thinkBase;
     // Explicit lifecycle state of the send ('generating' | 'paused' |
@@ -324,6 +330,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
@@ -406,11 +419,11 @@ export class LineEditor {
         this._inPaste = false;
         this._dotTimer = null;
         this._animating = false;
-        this._showHint = true;
         this._dotPhase = 0;
         this._thinkBase = '';
         this._sendState = '';
         this._lastStatusBlock = '';
+        this._blockRows = 0;
         this._wasRaw = false;
         this._onData = (b) => this._handle(b);
         this._resizeTimer = null;
@@ -665,8 +678,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 +890,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 +930,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 +953,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 +984,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 +1028,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)
@@ -1005,10 +1067,10 @@ export class LineEditor {
     _dots(n) {
         return renderDots(n);
     }
-    // Status-line hint ("Esc — stop"), localized.
+    // Status-line hint ("Esc — stop"), localized. Shown for every animated
+    // state: Esc really aborts both a generation and a running tool (the Bash
+    // child is killed via AbortSignal), so the promise is accurate.
     _hint() {
-        if (!this._showHint)
-            return '';
         return theme.dim('  ·  ' + translate(this.locale)('spinner.hint'));
     }
     // The lifecycle phase prefix for the status line, colored by meaning:
@@ -1044,13 +1106,8 @@ export class LineEditor {
     // Shared by the thinking spinner and the send-pause indicator, so the pause
     // is animated too (previously the pause was a static console line and the
     // dots stayed frozen).
-    //
-    // `showHint` (default true) controls the trailing "· Esc — стоп". While a
-    // TOOL runs we hide it: the tool's child process cannot be killed, so
-    // promising "Esc to stop" would be misleading.
-    _startAnimated(baseText, showHint = true) {
+    _startAnimated(baseText) {
         this._thinkBase = theme.brown(stripEllipsis(baseText));
-        this._showHint = showHint;
         this._dotPhase = 0;
         this.setStatus(this._thinkBase + this._dots(0) + this._hint());
         this._stopDots();
@@ -1128,7 +1185,7 @@ export class LineEditor {
             NL +
             rendered +
             NL +
-            theme.dim('─'.repeat(60)));
+            theme.dim(divider()));
     }
     // Warning to the operator (e.g. the agent stopped suspiciously).
     // Printed above the input line without overwriting it.

package/dist/self-review.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import fs from 'fs/promises';
-import { theme } from './theme.js';
+import { theme, divider } from './theme.js';
 import { translate, DEFAULT_LOCALE } from './i18n.js';
 import { fileURLToPath } from 'url';
 import { ZAMES_HOME } from './config.js';
@@ -116,7 +116,7 @@ export async function selfReview({ browser, focus, transcript, locale, }) {
     await fs.writeFile(reportPath, finalMessage || t('self.report_empty'), 'utf-8');
     // Compute what changed
     const changed = await diffFiles(SRC_DIR, snapDir);
-    console.log(theme.system('─'.repeat(60)));
+    console.log(theme.system(divider()));
     console.log(theme.system(t('self.report_path', { v: reportPath })));
     console.log(theme.system(t('self.snapshot_path', { v: snapDir })));
     if (changed.length) {

package/dist/spinner.js

@@ -1,5 +1,5 @@
 import ora from 'ora';
-import { theme } from './theme.js';
+import { theme, divider } from './theme.js';
 import { renderMarkdown } from './markdown.js';
 import { translate } from './i18n.js';
 // Phrases for the "agent is working" spinner. Chosen in random order.
@@ -59,14 +59,9 @@ export function createSpinner(locale = 'ru') {
     // "running" dot sequence. Shared by the thinking spinner and the send-pause
     // indicator, so the pause is animated too (before, it was a static line and
     // the dots did not move — the operator saw a frozen spinner).
-    //
-    // `showHint` (default true) controls the trailing "· Esc — стоп". While a
-    // tool runs we hide it: its process cannot be cancelled, so promising a stop
-    // would be misleading.
-    const startAnimated = (baseText, showHint = true) => {
+    const startAnimated = (baseText) => {
         animBase = theme.brown(stripEllipsis(baseText));
-        const hint = showHint ? HINT : '';
-        start(animBase + renderDots(0) + hint);
+        start(animBase + renderDots(0) + HINT);
         dotPhase = 0;
         if (dotTimer)
             clearInterval(dotTimer);
@@ -74,7 +69,7 @@ export function createSpinner(locale = 'ru') {
             if (!spinner)
                 return;
             dotPhase = (dotPhase + 1) % DOTS.length;
-            spinner.text = animBase + renderDots(dotPhase) + hint;
+            spinner.text = animBase + renderDots(dotPhase) + HINT;
         }, 400);
         animating = true;
         if (dotTimer.unref)
@@ -158,7 +153,7 @@ export function createSpinner(locale = 'ru') {
             // (which is highlighted by the prompt with a golden arrow).
             console.log(NL + theme.assistant(translate(locale)('editor.answer')) + NL);
             console.log(rendered);
-            console.log(theme.dim('─'.repeat(60)) + NL);
+            console.log(theme.dim(divider()) + NL);
         },
         warning: (msg) => {
             stop();

package/dist/theme.js

@@ -29,7 +29,16 @@ export const theme = {
     success: chalk.hex('#a9c08c'), // soft sage
     brown: chalk.hex('#a1723f'), // brown (status/spinner)
     toggleOn: chalk.hex('#6fd0b0'), // teal-green — a toggle is ON
-    toggleOff: chalk.hex('#4a4f5a'), // dim gray — a toggle is OFF
     bold: chalk.bold,
 };
+// Horizontal rule that separates the model's answer from the next block. It
+// spans the terminal width (capped at `max`) so it does not look stubby on a
+// wide terminal. Falls back to 60 columns when the width is unknown (non-TTY).
+// One column is kept free, like everywhere else in the status/input layout, so
+// a full-width rule cannot trigger autowrap.
+export function divider(max = 100) {
+    const cols = process.stdout.columns || 0;
+    const width = Math.max(20, Math.min(max, cols ? cols - 1 : 60));
+    return '─'.repeat(width);
+}
 export default theme;

package/package.json

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