zames_pro 2.29.16 → 2.31.0

package/dist/input.js

@@ -260,6 +260,11 @@ export class LineEditor {
     _lastStatusBlock;
     _wasRaw;
     _onData;
+    // On SIGWINCH we redraw the whole block so the layout follows the new
+    // terminal width. Debounced: a drag fires many resize events. `_onResize`
+    // is stored so it can be removed in dispose().
+    _onResize;
+    _resizeTimer;
     // History of sent messages (for the up/down arrows).
     history;
     _histIndex;
@@ -304,6 +309,10 @@ export class LineEditor {
     // A callback the editor calls to fetch the CURRENT token count before every
     // status render, so the status line stays fresh without the caller polling.
     onContextQuery;
+    // The context window size used for the fill percentage and its color. Kept
+    // as a mutable field (set from config.ui.contextLimit) so the status bar
+    // reflects the real limit instead of a hardcoded constant.
+    contextLimit;
     constructor({ prompt = '> ', commands = [], locale = 'ru', } = {}) {
         this.locale = locale;
         this.promptStr = prompt;
@@ -327,6 +336,26 @@ export class LineEditor {
         this._lastStatusBlock = '';
         this._wasRaw = false;
         this._onData = (b) => this._handle(b);
+        this._resizeTimer = null;
+        this._onResize = () => {
+            // Debounce: a window drag fires a burst of SIGWINCH events. We wait a
+            // short moment, then redraw the block at the NEW width.
+            if (this._resizeTimer)
+                clearTimeout(this._resizeTimer);
+            this._resizeTimer = setTimeout(() => {
+                this._resizeTimer = null;
+                // Repaint ONLY the status + input block. We deliberately do NOT clear
+                // the whole viewport here: the operator's scrollback (the tool-call
+                // lines and answers printed above the input) must stay on screen.
+                // `_eraseBlock` erases from the top of the block DOWN (CR + ESC[J),
+                // so everything above it is preserved; then _writeBlock redraws the
+                // block at the new width. A slight leftover is possible at extreme
+                // width changes, but losing the history is far worse.
+                this._render();
+            }, 120);
+            if (this._resizeTimer.unref)
+                this._resizeTimer.unref();
+        };
         this.history = [];
         this._histIndex = 0;
         this._histDraft = '';
@@ -343,6 +372,7 @@ export class LineEditor {
         this.contextTokens = null;
         this.thinkingEnabled = false;
         this.searchEnabled = false;
+        this.contextLimit = CONTEXT_LIMIT;
         this.onToggleQuery = null;
         this.onContextQuery = null;
     }
@@ -370,7 +400,9 @@ export class LineEditor {
                 const n = this.onContextQuery();
                 this.contextTokens = typeof n === 'number' ? n : null;
                 this.contextStatus =
-                    n === null || n === undefined ? null : formatTokenStatus(n) || null;
+                    n === null || n === undefined
+                        ? null
+                        : formatTokenStatus(n, this.contextLimit) || null;
             }
             catch {
                 // A broken callback must never break the render.
@@ -384,7 +416,7 @@ export class LineEditor {
         const ctx = this._contextForRender();
         if (!ctx)
             return '';
-        const level = tokenStatusLevel(this.contextTokens);
+        const level = tokenStatusLevel(this.contextTokens, this.contextLimit);
         if (level === 'high')
             return theme.error(ctx);
         if (level === 'warn')
@@ -392,11 +424,11 @@ export class LineEditor {
         return theme.success(ctx);
     }
     // Icons for the DeepSeek toggles: 🧠 "Deep thinking" and 🌐 "Smart search",
-    // shown before the context counter. Only the ENABLED toggle is shown, in
-    // green. A hidden icon means OFF — this does not rely on the terminal
-    // honoring the ANSI color (it ignores it for emoji), so there is no
-    // ambiguity. U+FE0E forces the monochrome TEXT presentation so the green is
-    // actually visible.
+    // shown before the context counter. Only the ENABLED toggles are shown, so
+    // the state is unambiguous WITHOUT relying on the terminal coloring the
+    // emoji: an icon present = ON, absent = OFF. Emoji are (almost) never
+    // colored by ANSI, so a "dim" vs "green" pair of the SAME emoji would look
+    // identical — that is why the disabled icon is hidden instead.
     _toggleIcons() {
         const TEXT = '\uFE0E';
         const parts = [];
@@ -466,12 +498,18 @@ export class LineEditor {
         stdin.resume();
         process.stdout.write(ESC + '[?2004h');
         stdin.on('data', this._onData);
+        // Redraw on terminal resize so the layout follows the new width instead
+        // of leaving artifacts from the old one.
+        process.stdout.on('resize', this._onResize);
         this._writeBlock();
         return true;
     }
     dispose() {
         const stdin = process.stdin;
         stdin.removeListener('data', this._onData);
+        process.stdout.removeListener('resize', this._onResize);
+        if (this._resizeTimer)
+            clearTimeout(this._resizeTimer);
         process.stdout.write(ESC + '[?2004l');
         this._stopDots();
         if (this.rendered)
@@ -529,9 +567,16 @@ export class LineEditor {
     setContextStatus(tokens) {
         this.contextTokens =
             typeof tokens === 'number' && Number.isFinite(tokens) ? tokens : null;
-        this.contextStatus = formatTokenStatus(tokens) || null;
+        this.contextStatus = formatTokenStatus(tokens, this.contextLimit) || null;
         this._render();
     }
+    // Update the context window size (from config.ui.contextLimit). The next
+    // render recomputes the percentage and its color with the new limit.
+    setContextLimit(limit) {
+        if (typeof limit === 'number' && Number.isFinite(limit) && limit > 0) {
+            this.contextLimit = limit;
+        }
+    }
     // Update the interface language (labels: hint, answer marker, pause).
     setLocale(locale) {
         this.locale = locale;
@@ -735,6 +780,17 @@ export class LineEditor {
         this._eraseBlock();
         this._writeBlock();
     }
+    // Full-screen clear (like /clear in a shell) followed by a fresh repaint of
+    // the status + input block. Used by /new and /resume so a new/resumed chat
+    // starts on a clean terminal instead of under pages of the previous chat.
+    // We do NOT clear the scrollback here: the operator may still want it.
+    clearScreen() {
+        this._eraseBlock();
+        process.stdout.write(ESC + '[2J' + ESC + '[H');
+        this.rendered = false;
+        this._lastStatusBlock = '';
+        this._writeBlock();
+    }
     // Repaint ONLY the input rows, leaving the status/spinner block untouched.
     // Used for buffer/cursor changes (typing, arrows, backspace, …): the status
     // line has its OWN animation timer, and repainting it on every keystroke
@@ -874,7 +930,8 @@ export class LineEditor {
         this.setStatus('');
     }
     toolCall(name, args) {
-        const preview = safeJson(args).slice(0, 120);
+        const full = safeJson(args);
+        const preview = full.slice(0, 120) + (full.length > 120 ? ' …' : '');
         this.printAbove(theme.tool('🔧 ' + name) + ' ' + theme.dim(preview));
         // A tool may run for a long time (Bash, npm test, MCP). Without an active
         // animation the operator sees a frozen screen and cannot tell work is in
@@ -887,18 +944,36 @@ export class LineEditor {
     toolResult(result) {
         this.stop();
         const text = typeof result === 'string' ? result : safeJson(result);
-        const preview = text.slice(0, 200).split(NL).join(' ↵ ');
+        const preview = text.slice(0, 200).split(NL).join(' ↵ ') + (text.length > 200 ? ' …' : '');
         this.printAbove(theme.toolResult('   → ' + preview));
     }
     assistant(msg) {
         this.stop();
         const rendered = renderMarkdown(msg);
+        // Show the used context size at the END of the answer too. During
+        // generation it lives in the status line, but ui.stop() clears that right
+        // before this call, so the operator lost the number exactly when the
+        // answer arrived. Read it fresh via onContextQuery and append it dimmed
+        // under the answer divider.
+        let ctxLine = '';
+        if (this.onContextQuery) {
+            try {
+                const n = this.onContextQuery();
+                const txt = formatTokenStatus(n, this.contextLimit);
+                if (txt)
+                    ctxLine = NL + theme.dim(txt);
+            }
+            catch {
+                // never break the render
+            }
+        }
         this.printAbove(NL +
             theme.assistant(translate(this.locale)('editor.answer')) +
             NL +
             rendered +
             NL +
-            theme.dim('─'.repeat(60)));
+            theme.dim('─'.repeat(60)) +
+            ctxLine);
     }
     // Warning to the operator (e.g. the agent stopped suspiciously).
     // Printed above the input line without overwriting it.

package/package.json

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