zames_pro 2.83.1 → 2.83.4

package/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.83.4] - 2026-10-27
+
+### Fixed
+
+- **ui:** theme the input text, the status row and the input frame
+
+## [2.83.2] - 2026-10-27
+
+### Fixed
+
+- **ui:** repaint the model answer and the code highlighting on a theme switch
+
 ## [2.83.1] - 2026-10-27
 
 ### Added

package/README.md

@@ -633,6 +633,11 @@ are ports of well-known editor schemes:
 `zames` (default), `one-dark`, `dracula`, `gruvbox`, `nord`, `monokai`,
 `solarized-dark`, `tokyo-night`.
 
+A theme repaints EVERYTHING: the interface, the agent's answers, the code
+highlighting inside them and the input frame. The frame itself is a separate
+setting: `/config set ui.inputBorder <round|single|double|bold|none>`
+(default `round`; `none` removes it).
+
 Agent data is stored in `~/.zames`: browser profile, logs, undo history, sessions.
 
 ## FAQ
@@ -1356,6 +1361,10 @@ enum переключаются на месте; числа и строки от
 `zames` (по умолчанию), `one-dark`, `dracula`, `gruvbox`, `nord`, `monokai`,
 `solarized-dark`, `tokyo-night`.
 
+Тема перекрашивает ВСЁ: интерфейс, ответы агента, подсветку кода в ответах и
+рамку ввода. Саму рамку можно менять отдельно: `/config set ui.inputBorder
+<round|single|double|bold|none>` (по умолчанию `round`, `none` — без рамки).
+
 Данные агента хранятся в `~/.zames`: профиль браузера, логи, история undo,
 сессии.
 

package/dist/config.js

@@ -134,6 +134,7 @@ export const DEFAULTS = {
     ui: {
         locale: DEFAULT_LOCALE,
         theme: DEFAULT_THEME,
+        inputBorder: 'round',
         contextLimit: 1_000_000,
         // 0 = auto: terminal width, capped at 100 columns (the historical width).
         answerWidth: 0,
@@ -291,6 +292,13 @@ export const CONFIG_SCHEMA = [
         labelKey: 'cfg.f.maxIterations',
         groupKey: 'cfg.group.agent',
     },
+    {
+        path: 'ui.inputBorder',
+        type: 'enum',
+        values: ['round', 'single', 'double', 'bold', 'none'],
+        labelKey: 'cfg.f.ui_inputBorder',
+        groupKey: 'cfg.group.ui',
+    },
     {
         path: 'ui.theme',
         type: 'enum',

package/dist/i18n/config.js

@@ -55,6 +55,10 @@ export const configMessages = {
         ru: 'Язык интерфейса и ответов агента',
         en: 'Interface and agent reply language',
     },
+    'cfg.f.ui_inputBorder': {
+        ru: 'Рамка строки ввода: round | single | double | bold | none',
+        en: 'Input box frame: round | single | double | bold | none',
+    },
     'cfg.f.ui_theme': {
         ru: 'Цветовая тема терминала',
         en: 'Terminal color theme',

package/dist/index.js

@@ -5,6 +5,7 @@ import fs from 'fs/promises';
 import { readFileSync, statSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { theme, applyTheme, themeColors, themeNames, currentThemeName, isThemeName, } from './theme.js';
+import { setInputBorder } from './tui/ui-colors.js';
 import { DeepSeekBrowser, headlessUACacheReady } from './browser.js';
 import { QwenBrowser } from './qwen-browser.js';
 import { GlmBrowser } from './glm-browser.js';
@@ -123,6 +124,10 @@ setAnswerWidth(config.ui?.answerWidth ?? 0);
 // banner, startup notices): theme.ts starts on the default and every call site
 // reads the live object, so one apply here repaints the whole session.
 applyTheme(config.ui?.theme);
+// Same for the input-box FRAME style: the TUI reads it per render, so one
+// apply before the editor is created covers the first paint (a /config change
+// goes through setConfigRuntime below).
+setInputBorder(config.ui?.inputBorder);
 // Current interface/agent language. Changed by the /config lang <ru|en> command.
 let currentLocale = isLocale(config.ui?.locale)
     ? config.ui.locale
@@ -1943,6 +1948,11 @@ async function main() {
         // object is shared and mutated in place, so every later render uses it;
         // the editor is asked for a full redraw because the rows already on screen
         // (status, prompt, hints) were painted with the OLD colors.
+        if (path === 'ui.inputBorder') {
+            setInputBorder(value);
+            if (editor)
+                editor.setTheme?.(themeColors());
+        }
         if (path === 'ui.theme') {
             const applied = applyTheme(value);
             config.ui.theme = applied;
@@ -2176,8 +2186,9 @@ async function main() {
             // read the shared UI map, and without a bump the operator would cycle
             // palette ids while the colors stayed those of the previous one.
             onAfterChange: (field) => {
-                if (field.path === 'ui.theme')
+                if (field.path === 'ui.theme' || field.path === 'ui.inputBorder') {
                     editor?.setTheme?.(themeColors());
+                }
             },
             locale: currentLocale,
         };

package/dist/input/layout.js

@@ -353,24 +353,26 @@ export function truncateToWidth(s, maxCols) {
     const reset = out.includes(ESC + '[') ? ESC + '[0m' : '';
     return out + reset + '…';
 }
-// Inner content width of the framed input box: the rounded border takes 1
-// column on each side and the box adds 1 column of padding on each side, so
-// the text must wrap to `cols - 4`. Exported so the layout ABOVE the box
+// Inner content width of the framed input box: the border takes 1 column on
+// each side (2 total, 0 when ui.inputBorder is 'none') and the box adds
+// 1 column of padding on each side, so the text wraps to `cols - border - 2`. Exported so the layout ABOVE the box
 // (FullScreenApp) and the box itself (InputLine) use ONE number — a mismatch
 // made the reserved height disagree with the rendered rows and the panel
 // overflowed.
-export function inputInnerCols(cols) {
-    return Math.max(4, (Number(cols) || 80) - 4);
+export function inputInnerCols(cols, borderCols = 2) {
+    return Math.max(4, (Number(cols) || 80) - borderCols - 2);
 }
 // Real height (rows) of the framed input box for the CURRENT buffer: 2 border
 // rows + the number of VISUAL rows the buffer wraps to. Using the LOGICAL line
 // count (buf.split('\n').length) was wrong: a long line wraps and renders MORE
 // rows than it has newlines, so the box was reserved too few rows, the second
 // line printed OVER the first and the cursor landed on the wrong row.
-export function inputBoxRows(prompt, buf, cursor, cols) {
-    const inner = inputInnerCols(cols);
+export function inputBoxRows(prompt, buf, cursor, cols, borderCols = 2) {
+    const inner = inputInnerCols(cols, borderCols);
     const rows = layoutInput(prompt, buf, cursor, inner).rows.length;
-    return 2 + Math.max(1, rows);
+    // Two BORDER rows only when a frame is drawn ('none' reserves just the text).
+    const borderRows = borderCols > 0 ? 2 : 0;
+    return borderRows + Math.max(1, rows);
 }
 export function layoutInput(promptStr, buf, cursor, cols) {
     // Reserve the LAST column. If a printed row reaches exactly `cols` columns,

package/dist/markdown.js

@@ -1,30 +1,73 @@
 import { render } from 'markdansi';
-import { highlight } from 'cli-highlight';
+import { highlight, DEFAULT_THEME as HL_DEFAULT_THEME, plain, } from 'cli-highlight';
 import supportsHyperlinks from 'supports-hyperlinks';
-const theme = {
-    heading: { color: '#9fb8d8', bold: true },
-    strong: { color: '#e6e0cc', bold: true },
-    emph: { color: '#cfc9b0', italic: true },
-    inlineCode: { color: '#9ecb9e' },
-    blockCode: { color: '#c9d1c9' },
-    code: { color: '#9ecb9e' },
-    link: { color: '#8fb8d8', underline: true },
-    quote: { color: '#8a8f9a', italic: true },
-    hr: { color: '#5b616e' },
-    listMarker: { color: '#8a9bb5' },
-    tableHeader: { color: '#9fb8d8', bold: true },
-    tableCell: { color: '#d0d0d0' },
-};
-function highlighter(code, lang) {
-    try {
-        return highlight(code, {
-            language: lang || 'plaintext',
-            ignoreIllegals: true,
-        });
-    }
-    catch {
-        return code;
-    }
+import { themeColors } from './theme.js';
+/**
+ * The Markdown theme for one palette. Rebuilt on every render (it is cheap) so
+ * the answers follow a live theme switch; the module no longer freezes the
+ * colors at import time.
+ */
+function mdTheme(p) {
+    return {
+        heading: { color: p.taskSummary, bold: true },
+        strong: { color: p.assistant, bold: true },
+        emph: { color: p.assistant, italic: true },
+        inlineCode: { color: p.success },
+        blockCode: { color: p.toolResult },
+        code: { color: p.success },
+        link: { color: p.dir, underline: true },
+        quote: { color: p.system, italic: true },
+        hr: { color: p.dim },
+        listMarker: { color: p.tool },
+        tableHeader: { color: p.taskSummary, bold: true },
+        tableCell: { color: p.assistant },
+    };
+}
+/**
+ * Syntax highlighting for a code block, mapped onto the palette. Without this
+ * the highlighter used cli-highlight's DEFAULT_THEME (chalk's blue/red/green),
+ * which ignores the selected theme entirely and looked off in every non-zames
+ * palette. Tokens we do not map fall back to `plain` — NOT to the default
+ * theme — so nothing outside the palette can leak in.
+ */
+function hlTheme(p) {
+    return {
+        keyword: (s) => wrap(p.prompt, s),
+        built_in: (s) => wrap(p.tool, s),
+        type: (s) => wrap(p.taskSummary, s),
+        literal: (s) => wrap(p.prompt, s),
+        number: (s) => wrap(p.success, s),
+        regexp: (s) => wrap(p.error, s),
+        string: (s) => wrap(p.success, s),
+        comment: (s) => wrap(p.dim, s),
+        class: (s) => wrap(p.taskSummary, s),
+        function: (s) => wrap(p.dir, s),
+        title: (s) => wrap(p.dir, s),
+        params: (s) => wrap(p.assistant, s),
+        attr: (s) => wrap(p.tool, s),
+        variable: (s) => wrap(p.assistant, s),
+        doctag: (s) => wrap(p.system, s),
+        meta: (s) => wrap(p.system, s),
+        tag: (s) => wrap(p.prompt, s),
+        name: (s) => wrap(p.prompt, s),
+        section: (s) => wrap(p.taskSummary, s),
+        link: (s) => wrap(p.dir, s),
+        addition: (s) => wrap(p.success, s),
+        deletion: (s) => wrap(p.error, s),
+    };
+}
+/** Apply a palette color to a highlighted token. */
+function wrap(hex, s) {
+    return '\x1b[38;2;' + rgb(hex) + 'm' + s + '\x1b[39m';
+}
+/** `#rrggbb` -> the `r;g;b` part of a truecolor SGR sequence. */
+function rgb(hex) {
+    const h = hex.replace('#', '');
+    return (parseInt(h.slice(0, 2), 16) +
+        ';' +
+        parseInt(h.slice(2, 4), 16) +
+        ';' +
+        parseInt(h.slice(4, 6), 16));
 }
 // The answer width is the SHARED content width (src/width.ts), the same one
 // the operator's echoed text, the tool previews, the warnings and the divider
@@ -43,6 +86,7 @@ export function renderMarkdown(text) {
     // stay colored while everything else went plain.
     if (process.env.NO_COLOR)
         return String(text);
+    const p = themeColors();
     try {
         const width = contentWidth();
         return render(String(text), {
@@ -53,8 +97,12 @@ export function renderMarkdown(text) {
             // looked unformatted). `color: true` makes it always emit SGR; the ONE
             // opt-out is NO_COLOR, handled above.
             color: true,
-            theme: theme,
-            highlighter,
+            theme: mdTheme(p),
+            highlighter: (code, lang) => highlight(code, {
+                language: lang || 'plaintext',
+                ignoreIllegals: true,
+                theme: hlTheme(p),
+            }),
             codeBox: true,
             tableBorder: 'unicode',
             listIndent: 2,
@@ -68,4 +116,8 @@ export function renderMarkdown(text) {
         return String(text);
     }
 }
+// Keep the import meaningful for tree-shakers/readers: the default theme is
+// deliberately NOT used (see hlTheme), `plain` is the fallback contract.
+void HL_DEFAULT_THEME;
+void plain;
 export default renderMarkdown;

package/dist/tui/FullScreenApp.js

@@ -20,7 +20,7 @@ import { suggestRowCount } from '../input/suggest.js';
 import { truncateToWidth, visLen } from '../input/layout.js';
 import { fullScreenLayout } from './layout.js';
 import { useMouseWheel } from './useMouseWheel.js';
-import { UI } from './ui-colors.js';
+import { UI, inputBorderCols } from './ui-colors.js';
 /** The header bar: title, version, working directory. */
 function Header({ store }) {
     const state = useSyncExternalStore(store.subscribe, store.getSnapshot);
@@ -65,6 +65,7 @@ export function FullScreenApp({ store, inputProps, }) {
         buf: state.edit.buf,
         cursor: state.edit.cursor,
         suggestRows: suggestRowCount(state.edit.buf, state.commands, cols),
+        borderCols: inputBorderCols(),
     });
     const logHeight = fsLayout.logHeight;
     // Window the log BY RENDERED ROW: a long wrapped answer can be taller than

package/dist/tui/InputLine.js

@@ -16,11 +16,11 @@ import { insertText, insertPaste, insertNewline, backspace, del, moveLeft, moveR
 import { dispatchKey, parseCsiU } from './keys.js';
 import { useSyncExternalStore } from 'react';
 import { matchSlashCommands, suggestWindow, completeSlashCommand, } from '../input/suggest.js';
-import { UI } from './ui-colors.js';
+import { UI, inputBorderStyle } from './ui-colors.js';
 /** Render the visual rows of the buffer with the prompt on the first row. */
 function InputRows({ prompt, buf, cols, }) {
     const lay = layoutInput(prompt, buf, 0, cols);
-    return (_jsx(Box, { flexDirection: "column", children: lay.rows.map((r, i) => (_jsxs(Text, { children: [_jsx(Text, { color: UI.accent, bold: true, children: r.prefix }), r.text] }, i))) }));
+    return (_jsx(Box, { flexDirection: "column", children: lay.rows.map((r, i) => (_jsxs(Text, { children: [_jsx(Text, { color: UI.accent, bold: true, children: r.prefix }), _jsx(Text, { color: UI.text, children: r.text })] }, i))) }));
 }
 export function InputLine(props) {
     const { columns } = useWindowSize();
@@ -49,7 +49,11 @@ export function InputLine(props) {
     // `Math.max(4, cols - 4)` here was one independent copy that could drift from
     // the reservation (the box then rendered more rows than were reserved and the
     // input rows overprinted the status bar).
-    const innerCols = inputInnerCols(cols);
+    // The frame style comes from ui.inputBorder (set live by /config): round
+    // (default), single, double, bold, none. Read per render so a switch applies
+    // immediately; 'none' also frees the two border columns for the text.
+    const borderStyle = inputBorderStyle();
+    const innerCols = inputInnerCols(cols, borderStyle ? 2 : 0);
     // Mirror the state into a ref so the useInput callback (a stable closure Ink
     // calls for every key) always sees the latest values.
     const stRef = useRef(st);
@@ -321,5 +325,5 @@ export function InputLine(props) {
                     }), moreCount > 0 && (_jsx(Text, { color: UI.dim, children: '   ' +
                             t('editor.more', { n: String(moreCount) }) +
                             '  ' +
-                            t('editor.page_hint') }))] })), _jsx(Box, { borderStyle: "round", borderColor: props.locked ? UI.dim : UI.accent, paddingLeft: 1, paddingRight: 1, flexDirection: "column", children: _jsx(InputRows, { prompt: props.prompt, buf: st.buf, cols: innerCols }) })] }));
+                            t('editor.page_hint') }))] })), _jsx(Box, { borderStyle: borderStyle, borderColor: props.locked ? UI.dim : UI.accent, paddingLeft: 1, paddingRight: 1, flexDirection: "column", children: _jsx(InputRows, { prompt: props.prompt, buf: st.buf, cols: innerCols }) })] }));
 }

package/dist/tui/StatusBar.js

@@ -115,12 +115,13 @@ function Badges({ state, budget = Infinity, }) {
     }
     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
-    // whole tree). The interval matches the old 400ms dot cadence.
+/**
+ * The LEFT part of the status row (spinner/pause/scroll marker) as a string.
+ * Extracted from the component so the text and its rules are unit-testable
+ * without a terminal; the component only truncates and colorizes it.
+ */
+export function statusLeftText(state, t, frame = 0) {
     const animating = state.busy || !!state.animBase;
-    const { frame } = useAnimation({ interval: 400, isActive: animating });
-    const t = translate(state.locale);
     const stateLbl = stateLabel(state, state.locale);
     let left;
     if (state.pendingText) {
@@ -147,20 +148,31 @@ export function StatusBar({ state, divider = true, }) {
     // When the log is scrolled up, show a marker in the status line (NOT as a
     // separate row below the input — that pushed the panel up and made the input
     // jump). It replaces the spinner text while scrolled, so it never adds a row.
+    // It carries NO timer: the elapsed label belongs to an animation, and a
+    // counter running next to «scrolled 5 lines» only ate width.
     const scrollNote = state.scroll > 0
-        ? translate(state.locale)('status.scrolled', {
-            n: String(state.scroll),
-        })
+        ? translate(state.locale)('status.scrolled', { n: String(state.scroll) })
         : '';
-    const leftText = scrollNote || prefix + left;
+    return scrollNote || prefix + left;
+}
+export function StatusBar({ state, divider = true, }) {
+    // Drive the spinner from Ink's shared animation timer (one timer for the
+    // whole tree). The interval matches the old 400ms dot cadence.
+    const animating = state.busy || !!state.animBase;
+    const { frame } = useAnimation({ interval: 400, isActive: animating });
+    const t = translate(state.locale);
+    const leftText = statusLeftText(state, t, frame);
     const showLeft = !!leftText;
-    // 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.
+    // Keep the row on ONE line: the left status may use whatever the BADGES do
+    // not need, minus a small gap so the two never touch. A fixed "a third of
+    // the width" budget cut the pause counter mid-number («5…») while half the
+    // row sat empty; measuring the badges (they are DROPPED whole when the row
+    // is tight, the context counter survives longest) is both accurate and
+    // keeps the layout stable.
     const cols = useWindowSize().columns || 80;
-    const leftBudget = Math.max(0, Math.min(Math.floor(cols / 3), cols - 14));
+    const badgeW = badgeTextWidth(state);
+    const gap = badgeW > 0 ? 2 : 0;
+    const leftBudget = Math.max(0, cols - 2 - badgeW - gap);
     const leftOut = showLeft ? truncateToWidth(leftText, leftBudget) : '';
     return (_jsxs(Box, { flexDirection: "column", children: [divider ? _jsx(Text, { color: UI.border, children: '─'.repeat(cols) }) : null, _jsxs(Box, { flexDirection: "row", width: Math.max(1, cols - 2), height: 1, children: [_jsx(Text, { color: UI.accentDim, children: leftOut || ' ' }), _jsx(Box, { flexGrow: 1 }), _jsx(Badges, { state: state, budget: Math.max(0, cols - 2 - visLen(leftOut)) })] })] }));
 }

package/dist/tui/layout.js

@@ -13,7 +13,7 @@ export const HINT_ROWS = 1;
 export function fullScreenLayout(input) {
     const termRows = Math.max(1, Math.floor(input.termRows) || 24);
     const cols = Math.max(1, Math.floor(input.cols) || 80);
-    const box = inputBoxRows(input.prompt, input.buf, input.cursor, cols);
+    const box = inputBoxRows(input.prompt, input.buf, input.cursor, cols, input.borderCols ?? 2);
     const suggestRows = Math.max(0, Math.floor(input.suggestRows) || 0);
     const panelRows = HEADER_ROWS + STATUS_ROWS + box + suggestRows + HINT_ROWS;
     const logHeight = Math.max(1, termRows - panelRows);

package/dist/tui/ui-colors.js

@@ -26,6 +26,36 @@ export function uiColorsFrom(p) {
     };
 }
 export const UI = uiColorsFrom(PALETTES[DEFAULT_THEME]);
+// Border STYLE of the framed surfaces (the input box today). Ink only ships a
+// handful of box styles; 'none' draws no frame at all. Kept next to the colors
+// because it is the same kind of presentation state, and mutated in place so a
+// /config switch applies without re-importing anything.
+let inputBorder = 'round';
+/** Switch the input frame style ('round'|'single'|'double'|'bold'|'none'). */
+export function setInputBorder(name) {
+    const v = String(name ?? '')
+        .trim()
+        .toLowerCase();
+    inputBorder =
+        v === 'none' ||
+            v === 'single' ||
+            v === 'double' ||
+            v === 'bold' ||
+            v === 'round'
+            ? v
+            : 'round';
+    return inputBorder;
+}
+/** The current input frame style as an Ink borderStyle value (none = no box). */
+export function inputBorderStyle() {
+    if (inputBorder === 'none')
+        return undefined;
+    return inputBorder;
+}
+/** Border columns the frame consumes (2 = left + right, 0 when off). */
+export function inputBorderCols() {
+    return inputBorderStyle() ? 2 : 0;
+}
 /** Repaint the Ink widgets with the palette of `name` (unknown -> default). */
 export function syncUiColors(name) {
     const id = isThemeName(name) ? name : DEFAULT_THEME;

package/llms-full.txt

@@ -618,6 +618,11 @@ are ports of well-known editor schemes:
 `zames` (default), `one-dark`, `dracula`, `gruvbox`, `nord`, `monokai`,
 `solarized-dark`, `tokyo-night`.
 
+A theme repaints EVERYTHING: the interface, the agent's answers, the code
+highlighting inside them and the input frame. The frame itself is a separate
+setting: `/config set ui.inputBorder <round|single|double|bold|none>`
+(default `round`; `none` removes it).
+
 Agent data is stored in `~/.zames`: browser profile, logs, undo history, sessions.
 
 ## FAQ

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.83.1",
+  "version": "2.83.4",
   "description": "Terminal coding agent that drives a real browser to chat with DeepSeek, Qwen or GLM — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {