zames_pro 2.74.0 → 2.75.0

package/dist/tui/StatusBar.js

@@ -1,8 +1,8 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useAnimation, useWindowSize } from 'ink';
 import { translate } from '../i18n.js';
 import { DOTS, stripEllipsis } from '../spinner.js';
-import { truncateToWidth } from '../input/layout.js';
+import { truncateToWidth, visLen } from '../input/layout.js';
 /** Elapsed seconds of the current animated phase ("0s", "45s", "2m 05s"). */
 function elapsedLabel(startedAt, animating) {
     if (!animating || !startedAt)
@@ -24,50 +24,69 @@ function stateLabel(state, locale) {
     return '';
 }
 /** Visible width of the badge row (used to reserve space for the left
- *  status). An emoji is counted as 2 columns; the rest as 1. Approximation is
- *  fine — the goal is only to avoid clipping the badges. */
-function badgeTextWidth(state) {
+ *  status). Measured with the shared `visLen` so wide chars (CJK/emoji) count
+ *  as 2 and the emoji's text-presentation selector (\uFE0E) as 0 — a plain
+ *  `.length` counted an emoji as 1 and a CJK badge was clipped on a narrow
+ *  terminal (BACKLOG T0.7). Exported so the width arithmetic is unit-tested
+ *  without rendering. */
+export function badgeTextWidth(state) {
     let w = 0;
     if (state.statusLine)
-        w += state.statusLine.length + 1;
+        w += visLen(state.statusLine) + 1;
     if (state.provider)
-        w += state.provider.length + 3;
+        w += visLen('[' + state.provider + '] ');
     if (state.queueLength > 0)
-        w += 2 + String(state.queueLength).length;
-    if (state.codeBlocks.length > 0)
-        w += 8;
+        w += visLen('⧗' + state.queueLength + ' ');
+    if (state.codeBlocks.length > 0) {
+        const idx = state.codeFocus >= 0 ? state.codeFocus + 1 : state.codeBlocks.length;
+        w += visLen('⌘ ' + idx + '/' + state.codeBlocks.length + ' ');
+    }
     if (state.tasks)
-        w += state.tasks.length + 1;
+        w += visLen(state.tasks) + 1;
+    const toggles = [];
     if (state.thinkingEnabled)
-        w += 3;
+        toggles.push('🧠\uFE0E');
     if (state.searchEnabled)
-        w += 3;
+        toggles.push('🌐\uFE0E');
+    if (toggles.length)
+        w += visLen(toggles.join(' ') + ' ');
     if (state.contextText) {
-        const marker = state.contextLevel === 'high' ? 2 : state.contextLevel === 'warn' ? 2 : 0;
-        w += state.contextText.length + marker;
+        const marker = state.contextLevel === 'high'
+            ? '⛔ '
+            : state.contextLevel === 'warn'
+                ? '▲ '
+                : '';
+        w += visLen(marker + state.contextText);
     }
     return w;
 }
-/** The badge row: statusLine, provider, queue, tasks, toggles, context. */
-function Badges({ state }) {
-    const parts = [];
+/** The badge row: statusLine, provider, queue, tasks, toggles, context.
+ *  `maxWidth` caps the row so it never wraps to a second line; when the badges
+ *  do not fit, the lowest-priority ones (statusLine, then provider) are
+ *  dropped first so the context counter — the most useful — survives. */
+function Badges({ state, budget = Infinity, }) {
+    // Each badge is (node, visible width); lowest-priority first so the context
+    // counter (last) survives when the row is tight.
+    const all = [];
+    const add = (key, w, node) => {
+        all.push({ key, w, node });
+    };
     if (state.statusLine) {
-        parts.push(_jsxs(Text, { color: "#808896", children: [state.statusLine, ' '] }, "sl"));
+        add('sl', visLen(state.statusLine) + 1, _jsxs(Text, { color: "#808896", children: [state.statusLine, ' '] }, "sl"));
     }
     if (state.provider) {
-        parts.push(_jsx(Text, { color: "#808896", children: '[' + state.provider + '] ' }, "prov"));
+        add('prov', visLen('[' + state.provider + '] '), _jsx(Text, { color: "#808896", children: '[' + state.provider + '] ' }, "prov"));
     }
     if (state.queueLength > 0) {
-        parts.push(_jsxs(Text, { color: "#c9a86a", children: ['⧗' + state.queueLength, ' '] }, "q"));
+        add('q', visLen('⧗' + state.queueLength + ' '), _jsxs(Text, { color: "#c9a86a", children: ['⧗' + state.queueLength, ' '] }, "q"));
     }
     if (state.codeBlocks.length > 0) {
-        // A hint that the last answer has copyable code: Ctrl+Y copies the last
-        // block (or the focused one), like a copy button in a GUI chat.
         const idx = state.codeFocus >= 0 ? state.codeFocus + 1 : state.codeBlocks.length;
-        parts.push(_jsx(Text, { color: "#7fc4f0", children: '⌘ ' + idx + '/' + state.codeBlocks.length + ' ' }, "code"));
+        const label = '⌘ ' + idx + '/' + state.codeBlocks.length + ' ';
+        add('code', visLen(label), _jsx(Text, { color: "#7fc4f0", children: label }, "code"));
     }
     if (state.tasks) {
-        parts.push(_jsxs(Text, { color: "#808896", children: [state.tasks, ' '] }, "t"));
+        add('t', visLen(state.tasks) + 1, _jsxs(Text, { color: "#808896", children: [state.tasks, ' '] }, "t"));
     }
     const toggles = [];
     if (state.thinkingEnabled)
@@ -75,7 +94,8 @@ function Badges({ state }) {
     if (state.searchEnabled)
         toggles.push('🌐\uFE0E');
     if (toggles.length) {
-        parts.push(_jsx(Text, { color: "#6fd0b0", children: toggles.join(' ') + ' ' }, "tg"));
+        const label = toggles.join(' ') + ' ';
+        add('tg', visLen(label), _jsx(Text, { color: "#6fd0b0", children: label }, "tg"));
     }
     if (state.contextText) {
         const color = state.contextLevel === 'high'
@@ -88,11 +108,20 @@ function Badges({ state }) {
             : state.contextLevel === 'warn'
                 ? '▲ '
                 : '';
-        parts.push(_jsx(Text, { color: color, children: marker + state.contextText }, "ctx"));
+        const label = marker + state.contextText;
+        add('ctx', visLen(label), _jsx(Text, { color: color, children: label }, "ctx"));
     }
-    if (!parts.length)
+    if (!all.length)
         return null;
-    return _jsx(Box, { children: parts });
+    // Drop badges from the FRONT (statusLine, provider, ... least important)
+    // until the row fits the budget. Keep at least the last (context).
+    let total = all.reduce((n, b) => n + b.w, 0);
+    let start = 0;
+    while (total > budget && start < all.length - 1) {
+        total -= all[start].w;
+        start++;
+    }
+    return _jsx(_Fragment, { children: all.slice(start).map((b) => b.node) });
 }
 export function StatusBar({ state, divider = true, }) {
     // Drive the spinner from Ink's shared animation timer (one timer for the
@@ -129,12 +158,13 @@ export function StatusBar({ state, divider = true, }) {
     const scrollNote = state.scroll > 0 ? `↑ прокручено на ${state.scroll} стр. · PgDn/End` : '';
     const leftText = scrollNote || prefix + left;
     const showLeft = !!leftText;
-    // Keep the badge row visible: the left status truncates to whatever space is
-    // left after the badges, instead of pushing them off the right edge (they
-    // used to be clipped: "[DeepSee⧗1 задачи: 3/...").
+    // Keep the row on ONE line. The left status gets at most a third of the
+    // width (it is the least important); the badges take the rest and DROP whole
+    // badges until they fit (the context counter survives longest). Estimating
+    // the badge width for the left budget was circular and let the row overshoot
+    // to a second line on a narrow terminal.
     const cols = useWindowSize().columns || 80;
-    const badgeWidth = badgeTextWidth(state);
-    const maxLeft = Math.max(0, cols - badgeWidth - 2);
-    const leftOut = showLeft ? truncateToWidth(leftText, maxLeft) : '';
-    return (_jsxs(Box, { flexDirection: "column", children: [divider ? _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(cols) }) : null, _jsxs(Box, { justifyContent: "space-between", children: [_jsx(Box, { children: leftOut ? _jsx(Text, { color: "#a1723f", children: leftOut }) : _jsx(Text, { children: " " }) }), _jsx(Badges, { state: state })] })] }));
+    const leftBudget = Math.max(0, Math.min(Math.floor(cols / 3), cols - 14));
+    const leftOut = showLeft ? truncateToWidth(leftText, leftBudget) : '';
+    return (_jsxs(Box, { flexDirection: "column", children: [divider ? _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(cols) }) : null, _jsxs(Box, { flexDirection: "row", width: Math.max(1, cols - 2), height: 1, children: [_jsx(Text, { color: "#a1723f", children: leftOut || ' ' }), _jsx(Box, { flexGrow: 1 }), _jsx(Badges, { state: state, budget: Math.max(0, cols - 2 - visLen(leftOut)) })] })] }));
 }

package/dist/tui/TuiApp.js

@@ -9,7 +9,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // (never repainted), the bottom section re-renders as state changes, so the
 // input stays pinned at the bottom while answers scroll up into scrollback.
 import React, { useSyncExternalStore } from 'react';
-import { Box } from 'ink';
+import { Box, useWindowSize } from 'ink';
 import { LogView } from './LogView.js';
 import { StatusBar } from './StatusBar.js';
 import { InputLine } from './InputLine.js';
@@ -23,6 +23,7 @@ export function TuiApp({ store, inputProps, initialPrintedCount = 0, }) {
     // + the suggestion popup (which renders above the box and would otherwise
     // shift the caret down by its row count). Without the suggestRows term the
     // caret drifted whenever the «/» list opened.
-    const suggestRows = suggestRowCount(state.edit.buf, state.commands);
+    const cols = useWindowSize().columns || 80;
+    const suggestRows = suggestRowCount(state.edit.buf, state.commands, cols);
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(LogView, { entries: entries }), _jsx(StatusBar, { state: state }), _jsx(InputLine, { ...inputProps, store: store, prompt: state.prompt, locale: state.locale, commands: state.commands, locked: state.locked, cursorTop: 3 + suggestRows })] }));
 }

package/dist/tui/edit.js

@@ -81,9 +81,29 @@ export function deleteWordLeft(s) {
     chars.splice(i, s.cursor - i);
     return { ...s, buf: chars.join(''), cursor: i };
 }
-/** Delete the word on the RIGHT of the cursor (Ctrl+Delete / Alt+Delete). */
+/**
+ * Delete the word on the RIGHT of the cursor (Ctrl+Delete / Alt+Delete).
+ *
+ * FALLBACK: at the END of the line there is no word to the right, so the key
+ * did NOTHING and the operator (whose terminal sends the standard xterm
+ * Ctrl+Delete) read it as "Ctrl+Delete does not delete the word before the
+ * cursor". Deleting the word on the LEFT there matches what other terminal
+ * editors do and what the operator expects, while keeping the standard
+ * right-delete when the cursor is mid-line.
+ */
 export function deleteWordRight(s) {
     const chars = charsOf(s);
+    // Nothing to the right (end of buffer or only whitespace to the newline):
+    // delete the word on the LEFT instead of doing nothing.
+    let probe = s.cursor;
+    while (probe < chars.length &&
+        chars[probe] !== NL &&
+        /\s/.test(chars[probe])) {
+        probe++;
+    }
+    if (probe >= chars.length || chars[probe] === NL) {
+        return deleteWordLeft(s);
+    }
     let i = s.cursor;
     while (i < chars.length && /\s/.test(chars[i]))
         i++;

package/dist/tui/keys.js

@@ -9,6 +9,39 @@
 // Kept free of React/Ink runtime imports beyond the Key TYPE, so it is
 // unit-testable.
 const LF = String.fromCharCode(10);
+/**
+ * Ctrl/Alt + named keys under the KITTY keyboard protocol (CSI-u). Ink's
+ * `parseKeypress` recognizes the MODIFIED ARROW forms but returns `name=''`
+ * for the modified Delete/Backspace codepoints (CSI 3;5u, 127;5u, ...), so
+ * `useInput` yields an empty input/name and the binding never fires — the
+ * operator's "Ctrl+Delete does nothing". The legacy LineEditor parsed these
+ * bytes itself; the TUI reads them from raw stdin (Ink hides `sequence`) and
+ * maps the known ones to the SAME actions so both editors behave alike.
+ *
+ * Returns null when the string is not one of these sequences. Pure + exported
+ * for tests.
+ */
+export function parseCsiU(raw) {
+    // CSI codepoint ; modifier [: eventType] u — e.g. ESC[3;5u (Ctrl+Delete),
+    // ESC[127;5u (Ctrl+Backspace), ESC[3u (plain Delete),
+    // ESC[127u (plain Backspace), ESC[13;5u (Ctrl+Enter).
+    const m = /^\u001b\[(\d+)(?:;(\d+))?(?::\d+)?u$/.exec(raw);
+    if (!m)
+        return null;
+    const cp = Number(m[1]);
+    const mod = m[2] ? Number(m[2]) - 1 : 0;
+    const ctrl = (mod & 4) !== 0;
+    const alt = (mod & 2) !== 0;
+    if (cp === 13 && (ctrl || alt))
+        return { type: 'newline' };
+    if (cp === 3) {
+        return ctrl || alt ? { type: 'deleteWordRight' } : { type: 'delete' };
+    }
+    if (cp === 127) {
+        return ctrl || alt ? { type: 'deleteWordLeft' } : { type: 'backspace' };
+    }
+    return null;
+}
 /**
  * Map a normalized Ink keypress to an editor action.
  *

package/dist/tui/store.js

@@ -40,7 +40,7 @@ function initialState() {
         queueLength: 0,
         tasks: '',
         provider: '',
-        mouseScroll: false,
+        mouseScroll: true,
         thinkingEnabled: false,
         searchEnabled: false,
         statusLine: '',

package/dist/tui/useMouseWheel.js

@@ -13,18 +13,32 @@
 // ALTERNATE-SCROLL: while the app is in the ALTERNATE SCREEN (full-screen
 // mode), terminals turn the mouse wheel into ARROW KEYS by default (DECSET
 // 1007, "alternate scroll mode"). Ink parses those arrows as normal Up/Down,
-// and the input editor at a buffer edge maps them to HISTORY — so the wheel
+// and the input editor at a buffer edge maps them to HISTORY -- so the wheel
 // scrolled the INPUT HISTORY instead of the log (the operator's bug).
 //
-// ORDER MATTERS and reporting is ALWAYS ON: some terminals only apply `1007l`
-// while mouse reporting is enabled, so sending `1007l` alone (the previous
-// behavior when ui.mouseScroll was off) was a no-op there and the wheel kept
-// arriving as arrows. We now enable 1000/1006 unconditionally and disable 1007
-// right after. Consequence: drag-select needs SHIFT (the standard TUI
-// convention — Shift+drag bypasses the app), which is the trade-off for a
-// working wheel. `enabled` only decides whether the wheel SCROLLS the log;
-// the events are consumed either way so they never reach the editor.
-import { useEffect } from 'react';
+// Two clear, MUTUALLY EXCLUSIVE modes (a terminal cannot do both at once):
+//   - SELECT (ui.mouseScroll=false): mouse reporting stays OFF, so the
+//     terminal owns the mouse -- drag-select works natively and the wheel is
+//     inert (no arrows, no history jump).
+//   - SCROLL (ui.mouseScroll=true): mouse reporting ON, so the wheel arrives
+//     as SGR events and scrolls the log; drag-select then needs SHIFT.
+//
+// THE CRITICAL DETAIL (this bug kept coming back): the mode sequences must be
+// written ONCE per mode change, NEVER per render. An earlier version listed
+// `onWheel` in the effect deps, but callers pass an inline arrow, so the
+// effect re-ran on EVERY render (the status spinner re-renders constantly) --
+// each cleanup wrote `1007h` (alternate-scroll ON) before the next setup wrote
+// `1007l`. A wheel notch that landed in that window became an ARROW and
+// scrolled the input history: the intermittent "either scroll or selection"
+// behaviour. The effect therefore depends ONLY on the mode + stdin, and the
+// callback is read from a ref (set in its own effect) so a new closure never tears
+// the terminal mode down.
+//
+// ORDER MATTERS: some terminals only apply `1007l` while mouse reporting is
+// enabled, so we enable 1000/1006 FIRST, then disable 1007. In SELECT mode we
+// actually want reporting off, so we send the on/off pair ONCE (the 1007l then
+// "sticks") and then leave reporting off.
+import { useEffect, useRef } from 'react';
 import { useStdin } from 'ink';
 /** True when a chunk contains an SGR mouse wheel event; returns the delta. */
 export function parseWheel(chunk) {
@@ -61,30 +75,64 @@ export function incompleteTail(chunk) {
 }
 const ESC = String.fromCharCode(27);
 /**
- * The terminal-mode sequences the hook writes. Exported PURE so a test can pin
- * the exact bytes AND their order (reporting FIRST, then 1007 off — some
- * terminals ignore `1007l` when mouse reporting is off, which is what made the
- * wheel keep scrolling the input history).
+ * The terminal-mode sequences the hook writes for a given mode. Exported PURE
+ * so a test can pin the exact bytes AND their order:
+ *   - SELECT (enabled=false): NO `1000h/1006h` in the STEADY state, `on`
+ *     only applies `1007l` (the one-time prime), and `off` guarantees the
+ *     reporting bits are clear on unmount;
+ *   - SCROLL (enabled=true): `1000h 1006h 1007l` in the STEADY state.
  */
-export function mouseModeSequences() {
-    const on = 
-    // 1000 = button-event tracking, 1006 = SGR extended coords, 1007 = off.
-    ESC + '[?1000h' + ESC + '[?1006h' + ESC + '[?1007l';
-    const off = ESC + '[?1006l' + ESC + '[?1000l' + ESC + '[?1007h';
-    return { on, off };
+export function mouseModeSequences(enabled) {
+    // 1000 = button-event tracking, 1006 = SGR extended coords, 1007 off always
+    // (being in alt-screen otherwise turns the wheel into arrows => history).
+    const reportingOn = ESC + '[?1000h' + ESC + '[?1006h';
+    const reportingOff = ESC + '[?1006l' + ESC + '[?1000l';
+    const alternateScrollOff = ESC + '[?1007l';
+    const alternateScrollOn = ESC + '[?1007h';
+    if (enabled) {
+        return {
+            on: reportingOn + alternateScrollOff,
+            off: reportingOff + alternateScrollOn,
+        };
+    }
+    // SELECT: the on/off pair is applied ONCE at mount so the 1007l sticks even
+    // though reporting is then off (some terminals ignore 1007l while reporting
+    // is off). After the prime the steady state has reporting OFF, and the
+    // listener is not bound, so nothing consumes the native selection.
+    return {
+        on: reportingOn + alternateScrollOff + reportingOff,
+        off: reportingOff + alternateScrollOn,
+    };
 }
 /**
  * Subscribe to wheel events on the given terminal and call `onWheel(delta)`
- * where delta > 0 means "scroll up / back". Enables SGR mouse reporting while
- * mounted and disables alternate-scroll so the wheel is never turned into
- * arrow keys.
+ * where delta > 0 means "scroll up / back".
+ *
+ * Two mutually exclusive modes:
+ *   - `enabled=false` (SELECT): mouse reporting stays OFF, native drag-select
+ *     works, the wheel is inert. The listener is still bound so an accidental
+ *     SGR byte from a previous mode never leaks into the editor as an arrow.
+ *   - `enabled=true` (SCROLL): reporting is on, the wheel scrolls the log
+ *     (via `onWheel`), drag-select needs Shift.
+ *
+ * The terminal mode is written ONCE per `enabled` change. The wheel listener
+ * is bound once and reads the latest `onWheel` from a ref, so an inline
+ * callback (a new identity every render) does NOT re-run the effect -- a
+ * re-run would momentarily re-enable alternate-scroll and let a wheel notch
+ * scroll the input history.
  */
-export function useMouseWheel(onWheel, enabled = true) {
+export function useMouseWheel(onWheel, enabled = false) {
     const { stdin, isRawModeSupported } = useStdin();
+    // The latest callback, without making the mode effect depend on its
+    // identity (callers pass an inline arrow).
+    const onWheelRef = useRef(onWheel);
+    useEffect(() => {
+        onWheelRef.current = onWheel;
+    }, [onWheel]);
     useEffect(() => {
         if (!isRawModeSupported)
             return;
-        const seq = mouseModeSequences();
+        const seq = mouseModeSequences(enabled);
         process.stdout.write(seq.on);
         // A sequence may be split across two chunks; carry the incomplete tail.
         let carry = '';
@@ -95,13 +143,14 @@ export function useMouseWheel(onWheel, enabled = true) {
             const scan = carry ? buf.slice(0, buf.length - carry.length) : buf;
             if (!scan.includes('\u001b[<'))
                 return;
-            // `enabled` decides whether the wheel SCROLLS; the event is consumed
-            // either way, so it never falls through to the editor as an arrow.
+            // SELECT mode ignores the wheel entirely (the event never reaches the
+            // editor either -- there is no reporting to generate it in the first
+            // place, but a stale SGR byte from a previous mode is swallowed here).
             if (!enabled)
                 return;
             const delta = parseWheel(scan);
             if (delta !== 0)
-                onWheel(delta);
+                onWheelRef.current(delta);
         };
         stdin.on('data', onData);
         return () => {
@@ -109,5 +158,7 @@ export function useMouseWheel(onWheel, enabled = true) {
             // Disable mouse reporting on unmount so normal selection works again.
             process.stdout.write(seq.off);
         };
-    }, [stdin, isRawModeSupported, onWheel, enabled]);
+        // `onWheel` is deliberately NOT a dependency: it is read via the ref so an
+        // inline callback does not tear the terminal mode down on every render.
+    }, [stdin, isRawModeSupported, enabled]);
 }

package/dist/tui/widgets.js

@@ -26,7 +26,12 @@ export function Select({ value, focused, }) {
 }
 /** A framed panel (rounded border) with an optional title bar and footer. */
 export function Panel({ title, subtitle, footer, width, children, }) {
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: UI.border, paddingX: 1, width: width, children: [title ? (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: UI.title, bold: true, children: title }), subtitle ? _jsx(Text, { color: UI.dim, children: subtitle }) : null] })) : null, title ? _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(40) }) : null, children, footer ? footer : null] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: UI.border, paddingX: 1, width: width, children: [title ? (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: UI.title, bold: true, children: title }), subtitle ? _jsx(Text, { color: UI.dim, children: subtitle }) : null] })) : null, title ? (_jsx(Text, { color: "#3a3f4b", children: '─'.repeat(panelInnerCols(width)) })) : null, children, footer ? footer : null] }));
+}
+/** Inner width (minus border + paddingX) the panel divider should span. */
+function panelInnerCols(width) {
+    const cols = width || process.stdout.columns || 80;
+    return Math.max(1, cols - 6);
 }
 /** A single hint chip: `↑/↓ select`. */
 export function Hint({ keys, label, }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.74.0",
+  "version": "2.75.0",
   "description": "Terminal coding agent that drives a real browser to chat with DeepSeek, Qwen and other web LLMs — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {
@@ -34,6 +34,7 @@
     "test:watch": "tsx --test --watch test/*.test.ts",
     "self-smoke": "tsx scripts/self-smoke.mts",
     "qwen-smoke": "tsx scripts/qwen-smoke.mts",
+    "qwen-models-smoke": "tsx scripts/qwen-models-smoke.mts",
     "render-demo": "tsx scripts/render-demo.mts",
     "render-how": "tsx scripts/render-how-it-works.mts",
     "build:readme": "tsx scripts/build-readme.mts",

package/scripts/inline-status-driver.mts

@@ -0,0 +1,31 @@
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+const NL = String.fromCharCode(10)
+const term = new Term(12, 60)
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/inline-status.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: '60', LINES: '12' },
+  },
+)
+child.stdout.on('data', (d) => term.write(d.toString('utf-8')))
+child.stderr.on('data', (d) => term.write(d.toString('utf-8')))
+setTimeout(() => {
+  const g = term.grid
+  if (g[term.r]) g[term.r][term.c] = String.fromCharCode(9673)
+  process.stdout.write(
+    g
+      .map((r) => r.join('').replace(/\s+$/, ''))
+      .map((l, n) => String(n).padStart(2) + '| ' + l)
+      .join(NL) +
+      NL +
+      'CURSOR row=' +
+      term.r +
+      NL,
+  )
+  child.kill('SIGTERM')
+}, 5000)
+child.on('close', () => process.exit(0))

package/scripts/inline-status.tsx

@@ -0,0 +1,33 @@
+import React from 'react'
+import { render } from 'ink'
+import { TuiStore } from '../src/tui/store.js'
+import { TuiApp } from '../src/tui/TuiApp.js'
+import { initialEditState } from '../src/tui/edit.js'
+const store = new TuiStore()
+store.set({
+  title: 'z',
+  version: '1',
+  workdir: '/tmp',
+  prompt: '> ',
+  locale: 'en',
+  commands: [],
+  edit: { ...initialEditState(), buf: 'abc' },
+  statusText: 'STATUS HERE',
+})
+const p = {
+  onSubmit: () => {},
+  onEscape: () => {},
+  onCtrlC: () => {},
+  onCopyCode: () => {},
+  onAttach: () => null,
+  onClipboard: () => Promise.resolve(null),
+  onHistoryChange: () => {},
+  onClearScreen: () => {},
+  attachments: [],
+  onPastesChange: () => {},
+}
+render(React.createElement(TuiApp, { store, inputProps: p }), {
+  exitOnCtrlC: false,
+  patchConsole: false,
+})
+setInterval(() => {}, 1 << 30)

package/scripts/mouse-churn.mts

@@ -0,0 +1,34 @@
+// Prove the mouse-mode churn is ZERO: mount the REAL TuiEditor, force several
+// store updates (like the 1s badge refresh does), and COUNT how many times the
+// raw stdout receives the mouse-mode sequences. With the effect depending on
+// an inline onWheel, the count grew per render (the wheel-vs-history bug);
+// with the ref fix, each mode byte is written ONCE.
+//
+// Exit code 0 = OK, 1 = churn detected. Prints a one-line verdict so the pty
+// test can assert on it.
+
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-mouse-churn-probe.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: '80', LIMES: '24' },
+  },
+)
+let out = ''
+child.stdout.on('data', (d) => (out += d.toString('utf-8')))
+child.stderr.on('data', (d) => (out += d.toString('utf-8')))
+setTimeout(() => child.kill('SIGTERM'), 8000)
+child.on('close', () => {
+  const count = (seq: string): number => out.split(seq).length - 1
+  const on = count('\u001b[?1000h')
+  const altOff = count('\u001b[?1007l')
+  const altOn = count('\u001b[?1007h')
+  console.log('MOUSE_CHURN 1000h=' + on + ' 1007l=' + altOff + ' 1007h=' + altOn)
+  const ok = on === 1 && altOff === 1 && altOn === 0
+  console.log(ok ? 'MOUSE_CHURN_OK' : 'MOUSE_CHURN_FAIL')
+  process.exit(ok ? 0 : 1)
+})