zames_pro 2.50.2 → 2.52.0

package/dist/input.js

@@ -316,6 +316,9 @@ export class LineEditor {
     // only the base text (remaining seconds) without restarting the timer.
     _animating;
     _dotPhase;
+    // When the current animated phase started, so the status can show its
+    // elapsed time. 0 when nothing is animating.
+    _animStart;
     _thinkBase;
     // Explicit lifecycle state of the send ('generating' | 'paused' |
     // 'settled' | ''). The thinking spinner already shows ACTIVITY, but it does
@@ -348,6 +351,21 @@ export class LineEditor {
     history;
     _histIndex;
     _histDraft;
+    // Incremental reverse-search over the history (Ctrl+R), bash-style.
+    _searchMode;
+    _searchQuery;
+    _searchIndex;
+    _searchSavedBuf;
+    // Called after every submit with the new full history, so the caller can
+    // persist it (the history otherwise dies with the process).
+    onHistoryChange;
+    // Snapshots of {buf, cursor} taken before each edit, so Ctrl+_ can undo a
+    // slip (a fat-fingered Ctrl+U / Ctrl+K used to wipe the whole line with no
+    // way back). Capped so a long session cannot grow it without bound.
+    _undoStack;
+    // True while a run of plain typing is in progress, so one undo snapshot
+    // covers the whole run instead of every character.
+    _typingRun;
     // Slash-command hints (shown when you type «/»).
     slashCommands;
     _suggestCount;
@@ -420,6 +438,7 @@ export class LineEditor {
         this._dotTimer = null;
         this._animating = false;
         this._dotPhase = 0;
+        this._animStart = 0;
         this._thinkBase = '';
         this._sendState = '';
         this._lastStatusBlock = '';
@@ -449,6 +468,13 @@ export class LineEditor {
         this.history = [];
         this._histIndex = 0;
         this._histDraft = '';
+        this._searchMode = false;
+        this._searchQuery = '';
+        this._searchIndex = -1;
+        this._searchSavedBuf = '';
+        this.onHistoryChange = null;
+        this._undoStack = [];
+        this._typingRun = false;
         this.slashCommands = commands;
         this._suggestCount = 0;
         this.pastes = [];
@@ -504,16 +530,17 @@ export class LineEditor {
         return this.contextStatus;
     }
     // The context text colored by fill level: green (ok), yellow (warn),
-    // red (high).
+    // red (high). A leading marker repeats the level as TEXT, so the signal
+    // survives on a terminal without color and for a color-blind operator.
     _contextText() {
         const ctx = this._contextForRender();
         if (!ctx)
             return '';
         const level = tokenStatusLevel(this.contextTokens, this.contextLimit);
         if (level === 'high')
-            return theme.error(ctx);
+            return theme.error('⛔ ' + ctx);
         if (level === 'warn')
-            return theme.warn(ctx);
+            return theme.warn('▲ ' + ctx);
         return theme.success(ctx);
     }
     // The queue badge ("⧗N") shown before the context counter when messages are
@@ -1109,16 +1136,34 @@ export class LineEditor {
     _startAnimated(baseText) {
         this._thinkBase = theme.brown(stripEllipsis(baseText));
         this._dotPhase = 0;
-        this.setStatus(this._thinkBase + this._dots(0) + this._hint());
+        // Remember when the animation began so the status can show how long the
+        // current phase has been running ("12s"): a long reasoning turn otherwise
+        // looks identical to a hung one.
+        this._animStart = Date.now();
+        this.setStatus(this._thinkBase + this._dots(0) + this._elapsedLabel() + this._hint());
         this._stopDots();
         this._dotTimer = setInterval(() => {
             this._dotPhase = (this._dotPhase + 1) % DOTS.length;
-            this.setStatus(this._thinkBase + this._dots(this._dotPhase) + this._hint());
+            this.setStatus(this._thinkBase +
+                this._dots(this._dotPhase) +
+                this._elapsedLabel() +
+                this._hint());
         }, 400);
         this._animating = true;
         if (this._dotTimer.unref)
             this._dotTimer.unref();
     }
+    // Elapsed seconds of the current animated phase, formatted for the status
+    // line ("0s", "45s", "2m 05s"). Empty while nothing is animating.
+    _elapsedLabel() {
+        if (!this._animating || !this._animStart)
+            return '';
+        const sec = Math.floor((Date.now() - this._animStart) / 1000);
+        const m = Math.floor(sec / 60);
+        const s = sec % 60;
+        const text = m > 0 ? m + 'm ' + String(s).padStart(2, '0') + 's' : s + 's';
+        return theme.dim(' · ' + text);
+    }
     thinking() {
         this._startThinking();
     }
@@ -1248,6 +1293,9 @@ export class LineEditor {
         // Add to history only non-empty messages that don't duplicate the previous one.
         if (text.trim() && this.history[this.history.length - 1] !== text) {
             this.history.push(text);
+            // Persist the new entry: the in-memory history dies with the process.
+            if (this.onHistoryChange)
+                this.onHistoryChange(this.history.slice());
         }
         this._histIndex = this.history.length;
         this._histDraft = '';
@@ -1272,6 +1320,26 @@ export class LineEditor {
         if (this.busy)
             this._startThinking();
     }
+    // Record the current buffer for Ctrl+_ undo. `coalesce` keeps one snapshot
+    // for a whole run of plain typing (so undo removes the run, not one char) —
+    // the run ends as soon as a non-typing key is handled.
+    _pushUndo(coalesce = false) {
+        if (coalesce && this._typingRun)
+            return;
+        this._undoStack.push({ buf: this.buf, cursor: this.cursor });
+        if (this._undoStack.length > 200)
+            this._undoStack.shift();
+        this._typingRun = coalesce;
+    }
+    // Ctrl+_ — restore the buffer to before the last edit.
+    _undoEdit() {
+        const prev = this._undoStack.pop();
+        if (!prev)
+            return;
+        this.buf = prev.buf;
+        this.cursor = Math.min(prev.cursor, Array.from(prev.buf).length);
+        this._typingRun = false;
+    }
     _insert(text) {
         const chars = Array.from(this.buf);
         const ins = Array.from(String(text));
@@ -1483,6 +1551,93 @@ export class LineEditor {
         }
         this.cursor = Array.from(this.buf).length;
     }
+    // ---------- reverse-search (Ctrl+R) ----------
+    // Start an incremental reverse search, keeping the current buffer aside so
+    // Esc restores it (bash behavior). An empty history leaves the editor
+    // untouched.
+    _searchStart() {
+        if (!this.history.length)
+            return;
+        this._searchMode = true;
+        this._searchQuery = '';
+        this._searchIndex = this.history.length - 1;
+        this._searchSavedBuf = this.buf;
+        this._searchRefresh(true);
+        this._searchStatus();
+    }
+    // Recompute the match for the current query. `resetToNewest` moves the
+    // cursor back to the newest entry (used when the query changes; a repeated
+    // Ctrl+R keeps scanning older entries from the current index).
+    _searchRefresh(resetToNewest = false) {
+        const q = this._searchQuery;
+        if (resetToNewest)
+            this._searchIndex = this.history.length - 1;
+        for (let i = this._searchIndex; i >= 0; i--) {
+            if (q === '' || this.history[i].toLowerCase().includes(q.toLowerCase())) {
+                this._searchIndex = i;
+                return;
+            }
+        }
+        // No match from here: signal it and leave the buffer as-is.
+        this._searchIndex = -1;
+    }
+    // Show the search state in the status line. The matched entry is previewed
+    // in the input line live, so Enter can accept it at once.
+    _searchStatus() {
+        const t = translate(this.locale);
+        const q = this._searchQuery;
+        if (this._searchIndex >= 0) {
+            // Set the matched buffer BEFORE setStatus(): setStatus renders the
+            // block, so the preview must already be in the buffer.
+            this.buf = this.history[this._searchIndex];
+            this.cursor = Array.from(this.buf).length;
+            this.setStatus(t('editor.search_prompt', { q }));
+        }
+        else {
+            this.setStatus(t('editor.search_fail', { q }));
+        }
+    }
+    // One more Ctrl+R: move to the PREVIOUS (older) match.
+    _searchNext() {
+        if (this._searchIndex > 0) {
+            const prev = this._searchIndex;
+            this._searchIndex = prev - 1;
+            this._searchRefresh(false);
+            // If nothing matched above `prev`, keep the previous match.
+            if (this._searchIndex < 0)
+                this._searchIndex = prev;
+        }
+        this._searchStatus();
+    }
+    // Enter: keep the matched buffer and leave search mode.
+    _searchAccept() {
+        this._searchMode = false;
+        this._searchQuery = '';
+        this.setStatus('');
+        this._render();
+    }
+    // Esc / Ctrl+C: leave search mode and restore the buffer typed before it.
+    _searchCancel() {
+        this._searchMode = false;
+        this._searchQuery = '';
+        this.buf = this._searchSavedBuf;
+        this.cursor = Array.from(this.buf).length;
+        this.setStatus('');
+        this._render();
+    }
+    // A character typed during search extends the query; Backspace trims it.
+    _searchInput(ch) {
+        this._searchQuery += ch;
+        this._searchRefresh(true);
+        this._searchStatus();
+    }
+    _searchBackspace() {
+        if (!this._searchQuery.length)
+            return;
+        this._searchQuery = this._searchQuery.slice(0, -1);
+        this._searchRefresh(true);
+        this._searchStatus();
+    }
     _handle(data) {
         let s = data.toString('utf-8');
         // While locked (a long operation is running), swallow all input except
@@ -1504,11 +1659,40 @@ export class LineEditor {
             }
             return;
         }
-        if (!this._inPaste && s === ESC) {
+        if (!this._inPaste && s === ESC && !this._searchMode) {
             if (this.onEscape)
                 this.onEscape();
             return;
         }
+        // While the reverse search (Ctrl+R) is active, the editor is in a modal
+        // state: every printable key extends the query, Ctrl+R scans older
+        // entries, Enter accepts and Esc/Ctrl+C cancels. Handling this BEFORE the
+        // normal key dispatch keeps the search self-contained.
+        if (this._searchMode) {
+            let i = 0;
+            while (i < s.length) {
+                const code = s.charCodeAt(i);
+                if (code === 18) {
+                    this._searchNext();
+                }
+                else if (code === 13 || code === 10) {
+                    this._searchAccept();
+                    return;
+                }
+                else if (code === 27 || code === 3) {
+                    this._searchCancel();
+                    return;
+                }
+                else if (code === 127 || code === 8) {
+                    this._searchBackspace();
+                }
+                else if (code >= 32) {
+                    this._searchInput(s[i]);
+                }
+                i++;
+            }
+            return;
+        }
         while (s.length) {
             if (this._inPaste) {
                 const end = s.indexOf(PASTE_END);
@@ -1626,12 +1810,19 @@ export class LineEditor {
                 continue;
             }
             if (code === 21) {
+                this._pushUndo();
                 this.buf = '';
                 this.cursor = 0;
                 this.pastes = [];
                 this._renderInputOnly();
                 continue;
             }
+            if (code === 31) {
+                // Ctrl+_ — undo the last edit in the input line.
+                this._undoEdit();
+                this._renderInputOnly();
+                continue;
+            }
             if (code === 22) {
                 // Ctrl+V: terminals rarely deliver an image as text here, so we try the
                 // OS clipboard first; if there is no image we fall back to reading the
@@ -1639,13 +1830,20 @@ export class LineEditor {
                 void this._tryClipboard();
                 continue;
             }
+            if (code === 18) {
+                // Ctrl+R — incremental reverse search over the input history.
+                this._searchStart();
+                continue;
+            }
             if (code === 23) {
+                this._pushUndo();
                 this._deleteWordLeft();
                 this._renderInputOnly();
                 continue;
             }
             if (code === 11) {
                 // Ctrl+K — delete from the cursor to the end of the line.
+                this._pushUndo();
                 const arr = Array.from(this.buf);
                 let e = this.cursor;
                 while (e < arr.length && arr[e] !== NL)
@@ -1656,6 +1854,7 @@ export class LineEditor {
                 continue;
             }
             if (code === 127 || code === 8) {
+                this._pushUndo(true);
                 this._backspace();
                 this._renderInputOnly();
                 continue;
@@ -1719,6 +1918,7 @@ export class LineEditor {
                     continue;
                 }
                 if (s.startsWith('[3~')) {
+                    this._pushUndo(true);
                     this._delete();
                     s = s.slice(3);
                     this._renderInputOnly();
@@ -1745,6 +1945,8 @@ export class LineEditor {
             }
             if (code < 32)
                 continue;
+            // Coalesce a run of typing into ONE undo snapshot.
+            this._pushUndo(true);
             this._insert(ch);
             this._renderInputOnly();
         }

package/dist/sessions.js

@@ -132,3 +132,29 @@ export function listSessions() {
 export function sessionsDir() {
     return SESSIONS_DIR;
 }
+// ---------- input history ----------
+// The LineEditor history otherwise dies with the process (it was in-memory
+// only), so the arrow keys / Ctrl+R could not recall anything from a previous
+// run. We persist it in ~/.zames/history.json, capped so the file cannot grow
+// without bound.
+const HISTORY_FILE = path.join(os.homedir(), '.zames', 'history.json');
+const HISTORY_LIMIT = 500;
+export function loadHistory() {
+    try {
+        const raw = JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf-8'));
+        if (!Array.isArray(raw))
+            return [];
+        return raw.filter((x) => typeof x === 'string');
+    }
+    catch {
+        return [];
+    }
+}
+export function saveHistory(history) {
+    try {
+        ensureDir();
+        const trimmed = history.slice(-HISTORY_LIMIT);
+        atomicWriteJson(HISTORY_FILE, trimmed);
+    }
+    catch { }
+}

package/package.json

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