zames_pro 2.16.0 → 2.18.0

package/dist/input.js

@@ -1,6 +1,7 @@
 import { theme } from './theme.js';
 import { renderMarkdown } from './markdown.js';
 import { randomThinkingPhrase, stripEllipsis } from './spinner.js';
+import { translate } from './i18n.js';
 import { AttachmentStore, parseImagePaste, looksLikeFilePath, } from './attachments.js';
 // A permanent input line at the bottom of the terminal + a status/output area above it.
 //
@@ -70,7 +71,6 @@ export function expandPastes(pastes, text) {
 // We align the width to the maximum (3) so the hint doesn't shift.
 const DOTS = ['', '.', '..', '...'];
 const DOTS_PAD = '   ';
-const HINT = theme.dim('  ·  Esc — стоп');
 function safeJson(v) {
     try {
         return JSON.stringify(v);
@@ -184,6 +184,9 @@ export class LineEditor {
     onCtrlC;
     _inPaste;
     _dotTimer;
+    // True while the dot-animation timer is running. Lets sendPause() update
+    // only the base text (remaining seconds) without restarting the timer.
+    _animating;
     _dotPhase;
     _thinkBase;
     _wasRaw;
@@ -212,7 +215,11 @@ export class LineEditor {
     // user could type and send a message mid-operation, and it would be queued
     // and sent right after the operation, breaking the restored session.
     locked;
-    constructor({ prompt = '> ', commands = [] } = {}) {
+    // Interface language for the editor's own labels (hint, answer marker,
+    // pause status). Everything the OPERATOR sees must be localized.
+    locale;
+    constructor({ prompt = '> ', commands = [], locale = 'ru' } = {}) {
+        this.locale = locale;
         this.promptStr = prompt;
         this.buf = '';
         this.cursor = 0;
@@ -226,6 +233,7 @@ export class LineEditor {
         this.onCtrlC = null;
         this._inPaste = false;
         this._dotTimer = null;
+        this._animating = false;
         this._dotPhase = 0;
         this._thinkBase = '';
         this._wasRaw = false;
@@ -362,6 +370,11 @@ export class LineEditor {
         this.promptStr = str;
         this._render();
     }
+    // Update the interface language (labels: hint, answer marker, pause).
+    setLocale(locale) {
+        this.locale = locale;
+        this._render();
+    }
     // Update slash-command descriptions (interface language change).
     setCommands(commands) {
         this.slashCommands = commands;
@@ -412,7 +425,7 @@ export class LineEditor {
             out += NL + lines.join(NL);
             const hidden = sugg.length - shown.length;
             if (hidden > 0)
-                out += NL + theme.dim('   …ещё ' + hidden);
+                out += NL + theme.dim('   ' + translate(this.locale)('editor.more', { n: hidden }));
         }
         process.stdout.write(out);
         const lastRow = lay.rows.length - 1;
@@ -449,36 +462,65 @@ export class LineEditor {
             clearInterval(this._dotTimer);
             this._dotTimer = null;
         }
+        this._animating = false;
     }
     _dots(n) {
         // The dots are the same color as the base and of fixed width — otherwise
         // the hint on the right "jumps" when the animation phase changes.
         return theme.brown(DOTS[n] + DOTS_PAD.slice(DOTS[n].length));
     }
+    // Status-line hint ("Esc — stop"), localized.
+    _hint() {
+        return theme.dim('  ·  ' + translate(this.locale)('spinner.hint'));
+    }
     _startThinking() {
         if (this.pendingText) {
-            this.setStatus(theme.prompt('✎ ') + this.pendingText + HINT);
+            this.setStatus(theme.prompt('✎ ') + this.pendingText + this._hint());
             return;
         }
-        this._thinkBase = theme.brown(stripEllipsis(randomThinkingPhrase()));
+        this._startAnimated(randomThinkingPhrase());
+    }
+    // Animated status: a brown base text plus a growing "running" dot sequence.
+    // 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).
+    _startAnimated(baseText) {
+        this._thinkBase = theme.brown(stripEllipsis(baseText));
         this._dotPhase = 0;
-        this.setStatus(this._thinkBase + this._dots(0) + HINT);
+        this.setStatus(this._thinkBase + this._dots(0) + this._hint());
         this._stopDots();
         this._dotTimer = setInterval(() => {
             this._dotPhase = (this._dotPhase + 1) % DOTS.length;
-            this.setStatus(this._thinkBase + this._dots(this._dotPhase) + HINT);
+            this.setStatus(this._thinkBase + this._dots(this._dotPhase) + this._hint());
         }, 400);
+        this._animating = true;
         if (this._dotTimer.unref)
             this._dotTimer.unref();
     }
     thinking() {
         this._startThinking();
     }
+    // The agent is waiting out the send-interval pause before a real send.
+    // Show it as an ANIMATED status with the remaining seconds. The browser
+    // calls this repeatedly (once per second), so we update only the base text
+    // and keep the running dot timer — otherwise the dots would restart from
+    // zero on every update and look frozen on a single dot.
+    sendPause(seconds) {
+        if (this.pendingText)
+            return;
+        const label = translate(this.locale)('spinner.pause', { n: seconds });
+        if (this._animating && this._dotTimer) {
+            this._thinkBase = theme.brown(stripEllipsis(label));
+            this.setStatus(this._thinkBase + this._dots(this._dotPhase) + this._hint());
+            return;
+        }
+        this._startAnimated(label);
+    }
     setPending(text) {
         this.pendingText = text && String(text).length ? String(text) : null;
         if (this.pendingText) {
             this._stopDots();
-            this.setStatus(theme.prompt('✎ ') + this.pendingText + HINT);
+            this.setStatus(theme.prompt('✎ ') + this.pendingText + this._hint());
         }
         else {
             this._startThinking();
@@ -500,7 +542,7 @@ export class LineEditor {
     assistant(msg) {
         this.stop();
         const rendered = renderMarkdown(msg);
-        this.printAbove(NL + theme.assistant('● Ответ') + NL + rendered + NL + theme.dim('─'.repeat(60)));
+        this.printAbove(NL + theme.assistant(translate(this.locale)('editor.answer')) + NL + rendered + NL + theme.dim('─'.repeat(60)));
     }
     // Warning to the operator (e.g. the agent stopped suspiciously).
     // Printed above the input line without overwriting it.

package/dist/spinner.js

@@ -20,6 +20,12 @@ export function createSpinner(locale = 'ru') {
     let dotTimer = null;
     let dotPhase = 0;
     let pending = null;
+    // Current animated base text and its dot renderer. Kept in variables (not
+    // captured in the interval closure) so sendPause() can update the text
+    // without restarting the dot animation — otherwise the dots would reset to
+    // zero every second and look frozen on a single dot.
+    let animBase = '';
+    let animating = false;
     // Dot animation: start from an empty string (0 dots), then grow.
     // We align the width to the maximum (3) so the hint doesn't shift.
     const DOTS = ['', '.', '..', '...'];
@@ -35,19 +41,23 @@ export function createSpinner(locale = 'ru') {
             clearInterval(dotTimer);
             dotTimer = null;
         }
+        animating = false;
         if (spinner)
             spinner.stop();
     };
     // Hint in the status line: while the agent works the terminal is live,
     // so you can type the next message. Without it this is not obvious.
     const HINT = theme.dim('  ·  ' + translate(locale)('spinner.hint'));
-    // Start the animated status: brown text + "running" dots.
-    const startThinking = () => {
-        const base = theme.brown(stripEllipsis(randomThinkingPhrase(locale)));
+    // Run the animated status line: a brown base text plus a growing/shrinking
+    // "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).
+    const startAnimated = (baseText) => {
+        animBase = theme.brown(stripEllipsis(baseText));
         // The dots are the same color as the base and of fixed width — otherwise
         // the hint on the right "jumps" when the animation phase changes.
         const dots = (n) => theme.brown(DOTS[n] + DOTS_PAD.slice(DOTS[n].length));
-        start(base + dots(0) + HINT);
+        start(animBase + dots(0) + HINT);
         dotPhase = 0;
         if (dotTimer)
             clearInterval(dotTimer);
@@ -55,11 +65,16 @@ export function createSpinner(locale = 'ru') {
             if (!spinner)
                 return;
             dotPhase = (dotPhase + 1) % DOTS.length;
-            spinner.text = base + dots(dotPhase) + HINT;
+            spinner.text = animBase + dots(dotPhase) + HINT;
         }, 400);
+        animating = true;
         if (dotTimer.unref)
             dotTimer.unref();
     };
+    // Start the animated status: brown text + "running" dots.
+    const startThinking = () => {
+        startAnimated(randomThinkingPhrase(locale));
+    };
     // Show the typed but not yet sent text instead of the spinner.
     // Lets you type a message right while the agent is working.
     const showPending = () => {
@@ -67,6 +82,7 @@ export function createSpinner(locale = 'ru') {
             clearInterval(dotTimer);
             dotTimer = null;
         }
+        animating = false;
         if (!spinner)
             spinner = ora('');
         spinner.start();
@@ -80,6 +96,23 @@ export function createSpinner(locale = 'ru') {
             }
             startThinking();
         },
+        // The agent is waiting out the send-interval pause before a real send.
+        // Show it as an ANIMATED status line with the remaining seconds, so the
+        // spinner keeps moving during the pause (previously a static console line
+        // was printed and the dots stayed frozen).
+        sendPause: (seconds) => {
+            if (pending)
+                return;
+            const label = translate(locale)('spinner.pause', { n: seconds });
+            // Update only the base text while the dot animation is already running,
+            // so the countdown refreshes without resetting the dots.
+            if (animating && dotTimer && spinner) {
+                animBase = theme.brown(stripEllipsis(label));
+                spinner.text = animBase + theme.brown(DOTS[dotPhase] + DOTS_PAD.slice(DOTS[dotPhase].length)) + HINT;
+                return;
+            }
+            startAnimated(label);
+        },
         // The text the user types while the agent is working.
         // Empty string / null — restore the regular spinner.
         setPending: (text) => {
@@ -106,7 +139,7 @@ export function createSpinner(locale = 'ru') {
             const rendered = renderMarkdown(msg);
             // Model answer marker: helps visually separate it from the user's input
             // (which is highlighted by the prompt with a golden arrow).
-            console.log(NL + theme.assistant('● Ответ') + NL);
+            console.log(NL + theme.assistant(translate(locale)('editor.answer')) + NL);
             console.log(rendered);
             console.log(theme.dim('─'.repeat(60)) + NL);
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.16.0",
+  "version": "2.18.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {
@@ -15,7 +15,7 @@
   ],
   "scripts": {
     "start": "node ./dist/index.js",
-    "dev": "tsx ./src/index.ts --dev",
+    "dev": "ZAMES_NET_DEBUG=1 tsx ./src/index.ts --dev",
     "build": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build",