zames_pro 2.73.11 → 2.75.0

package/dist/tui/ConfigMenu.js

@@ -0,0 +1,337 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The Ink-based CONFIG MENU — a drop-in alternative to the hand-rolled
+// `runConfigMenu` (src/config-menu.ts), used when `ui.tui` is enabled.
+//
+// It offers the same operations with a cleaner layout: a scrolling list of
+// settings grouped by section, ↑/↓ (or j/k) to move, g to jump to the next
+// group, Enter/Space to edit (boolean/enum toggle in place, number/string
+// prompt), d twice to reset, / to filter, q/Esc to quit.
+//
+// All strings come from i18n (cfg.*), so the menu is fully localized. The
+// component never touches config.ts directly: the caller passes get/set/reset
+// callbacks (the SAME ones the legacy menu takes), so the logic is shared.
+import { useMemo, useState } from 'react';
+import { Box, Text, useInput, useApp, useWindowSize } from 'ink';
+import { Checkbox, Select, UI, HintBar } from './widgets.js';
+/** Strip ANSI to measure a line's visible width. */
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '');
+}
+/** Visible width in columns (wide chars count 2). */
+function visCols(s) {
+    const str = stripAnsi(s);
+    let w = 0;
+    for (const ch of str) {
+        const cp = ch.codePointAt(0);
+        w += cp >= 0x1100 ? 2 : 1;
+    }
+    return w;
+}
+function displayValue(field, value, t) {
+    if (value === undefined)
+        return t('cfg.menu.default');
+    if (typeof value === 'boolean')
+        return value ? t('common.on') : t('common.off');
+    if (/password/i.test(field.path) && String(value).length > 0)
+        return '********';
+    return String(value);
+}
+export function ConfigMenuApp(opts) {
+    const { fields, t, get, set, reset, getDefault } = opts;
+    const { exit } = useApp();
+    const { columns, rows } = useWindowSize();
+    const [cursor, setCursor] = useState(0);
+    const [filterQuery, setFilterQuery] = useState('');
+    const [filterMode, setFilterMode] = useState(false);
+    const [editing, setEditing] = useState(false);
+    const [editBuf, setEditBuf] = useState('');
+    const [pendingReset, setPendingReset] = useState(null);
+    const [message, setMessage] = useState(null);
+    // `get`/`set` mutate the LIVE config object in place, so React has no state
+    // change to react to and the row kept the OLD value on screen after a
+    // toggle/cycle (the operator saw «ru» while the config already held «en»).
+    // Bump this counter after every mutation to force a re-render.
+    const [version, setVersion] = useState(0);
+    const bump = () => setVersion((v) => v + 1);
+    const visible = useMemo(() => {
+        const q = filterQuery.trim().toLowerCase();
+        if (!q)
+            return fields;
+        return fields.filter((f) => (f.path + ' ' + t(f.labelKey || f.path) + ' ' + t(f.groupKey))
+            .toLowerCase()
+            .includes(q));
+    }, [fields, filterQuery, t]);
+    const isModified = (f) => {
+        if (!getDefault)
+            return false;
+        const cur = get(f.path);
+        const def = getDefault(f.path);
+        try {
+            return JSON.stringify(cur) !== JSON.stringify(def);
+        }
+        catch {
+            return String(cur) !== String(def);
+        }
+    };
+    const commitEdit = () => {
+        const f = visible[cursor];
+        const raw = editBuf.trim();
+        setEditing(false);
+        setEditBuf('');
+        if (!f || !raw) {
+            setMessage(null);
+            return;
+        }
+        try {
+            set(f, raw);
+            bump();
+            setMessage(t('cfg.menu.saved', {
+                v: f.path,
+                value: displayValue(f, get(f.path), t),
+            }));
+        }
+        catch (e) {
+            setMessage(String(e.message || e));
+        }
+    };
+    const activate = () => {
+        const f = visible[cursor];
+        if (!f)
+            return;
+        if (f.type === 'boolean') {
+            set(f, get(f.path) === true ? 'false' : 'true');
+            bump();
+            setMessage(null);
+            return;
+        }
+        if (f.type === 'enum' && f.values && f.values.length) {
+            cycleEnum(f, 1);
+            return;
+        }
+        setEditing(true);
+        setEditBuf(get(f.path) === undefined ? '' : String(get(f.path)));
+    };
+    /** Cycle an enum value by `dir` (+1 next, -1 prev). */
+    const cycleEnum = (f, dir) => {
+        if (!f.values || !f.values.length)
+            return;
+        const cur = String(get(f.path) ?? '');
+        const idx = f.values.indexOf(cur);
+        const base = idx < 0 ? 0 : idx;
+        const next = f.values[(base + dir + f.values.length) % f.values.length];
+        set(f, next);
+        bump();
+        setMessage(null);
+    };
+    /** ←/→ acts on the focused row: cycle an enum, toggle a boolean. */
+    const lateral = (dir) => {
+        const f = visible[cursor];
+        if (!f)
+            return;
+        if (f.type === 'enum')
+            cycleEnum(f, dir);
+        else if (f.type === 'boolean') {
+            set(f, get(f.path) === true ? 'false' : 'true');
+            bump();
+            setMessage(null);
+        }
+    };
+    const quit = () => {
+        opts.onExit();
+        exit();
+    };
+    useInput((input, key) => {
+        if (editing) {
+            if (key.return) {
+                commitEdit();
+                return;
+            }
+            if (key.escape) {
+                setEditing(false);
+                setEditBuf('');
+                return;
+            }
+            if (key.ctrl && input === 'c') {
+                quit();
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setEditBuf((b) => b.slice(0, -1));
+                return;
+            }
+            if (input && input >= ' ')
+                setEditBuf((b) => b + input);
+            return;
+        }
+        if (filterMode) {
+            if (key.return || key.escape) {
+                setFilterMode(false);
+                return;
+            }
+            if (key.ctrl && input === 'c') {
+                quit();
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setFilterQuery((q) => q.slice(0, -1));
+                setCursor(0);
+                return;
+            }
+            if (input && input >= ' ') {
+                setFilterQuery((q) => q + input);
+                setCursor(0);
+            }
+            return;
+        }
+        if (key.escape ||
+            input === 'q' ||
+            input === 'Q' ||
+            (key.ctrl && input === 'c')) {
+            quit();
+            return;
+        }
+        if (input === '/') {
+            setFilterMode(true);
+            setMessage(null);
+            return;
+        }
+        if (key.leftArrow) {
+            lateral(-1);
+            return;
+        }
+        if (key.rightArrow) {
+            lateral(1);
+            return;
+        }
+        if (key.upArrow || input === 'k') {
+            setCursor((c) => visible.length ? (c - 1 + visible.length) % visible.length : 0);
+            setPendingReset(null);
+            setMessage(null);
+            return;
+        }
+        if (key.downArrow || input === 'j') {
+            setCursor((c) => (visible.length ? (c + 1) % visible.length : 0));
+            setPendingReset(null);
+            setMessage(null);
+            return;
+        }
+        if (input === 'g') {
+            // Jump to the first field of the NEXT group (and back to the top).
+            const curGroup = visible[cursor]?.groupKey;
+            let target = -1;
+            for (let k = cursor + 1; k < visible.length; k++) {
+                if (visible[k].groupKey !== curGroup) {
+                    target = k;
+                    break;
+                }
+            }
+            setCursor(target >= 0 ? target : 0);
+            setMessage(null);
+            return;
+        }
+        if (key.return || input === ' ') {
+            activate();
+            return;
+        }
+        if (input === 'd' || input === 'D') {
+            const f = visible[cursor];
+            if (!f)
+                return;
+            if (pendingReset === f.path) {
+                reset(f);
+                bump();
+                setMessage(t('cfg.reset', { v: f.path }));
+                setPendingReset(null);
+            }
+            else {
+                setPendingReset(f.path);
+                setMessage(t('cfg.menu.reset_confirm', { v: f.path }));
+            }
+            return;
+        }
+    });
+    // Windowed list: show a slice around the cursor. The window is measured in
+    // RENDERED ROWS, not items: each new group adds a header row, AND a label
+    // long enough to wrap takes more than one row. Counting one row per item
+    // let the block grow taller than the terminal and the top border/title
+    // scrolled off ("cut off at the top") on a narrow terminal.
+    const termRows = rows || 24;
+    const maxRows = Math.max(3, termRows - 8);
+    const innerCols = Math.max(1, (columns || 80) - 4);
+    const shown = useMemo(() => {
+        const groupStart = (i) => i === 0 || visible[i].groupKey !== visible[i - 1].groupKey;
+        // Rendered height of one item: 1 base row + wrapped extra rows. The label
+        // plus the value cell plus the path hint is approximated by the raw label
+        // length; over-estimating is safe (it only shortens the window).
+        const itemRows = (i) => {
+            const f = visible[i];
+            const label = f.labelKey ? t(f.labelKey) : f.path;
+            return Math.max(1, Math.ceil((label.length + 12) / innerCols));
+        };
+        const rowsIn = (a, b) => {
+            let r = 0;
+            for (let i = a; i < b; i++) {
+                if (groupStart(i))
+                    r++;
+                r += itemRows(i);
+            }
+            return r;
+        };
+        if (!visible.length)
+            return { start: 0, end: 0 };
+        let start = cursor;
+        let end = cursor + 1;
+        // Fill downward first, then upward, so the cursor stays visible and the
+        // window uses the whole budget.
+        while (end < visible.length && rowsIn(start, end + 1) <= maxRows)
+            end++;
+        while (start > 0 && rowsIn(start - 1, end) <= maxRows)
+            start--;
+        return { start, end };
+    }, [cursor, visible, maxRows, innerCols, t]);
+    const usable = Math.max(1, (columns || 80) - 1);
+    void visCols;
+    void usable;
+    // Referenced so the value-cell recompute below depends on the mutation
+    // counter (a pure `get()` call has no reactive dependency of its own).
+    void version;
+    const items = [];
+    let lastGroup = '';
+    for (let i = shown.start; i < shown.end; i++) {
+        const f = visible[i];
+        const g = f.groupKey;
+        if (i === shown.start || g !== lastGroup) {
+            items.push(_jsx(Text, { color: UI.system, children: '  ' + t(f.groupKey).toUpperCase() }, 'g' + i));
+            lastGroup = g;
+        }
+        const selected = i === cursor;
+        const label = f.labelKey ? t(f.labelKey) : f.path;
+        const raw = get(f.path);
+        const mod = isModified(f) ? '*' : '';
+        // The VALUE cell depends on the field type: a checkbox for booleans, an
+        // inline select for enums, plain text otherwise. The selected row shows
+        // the path on the right as a hint.
+        let valueCell;
+        if (f.type === 'boolean') {
+            valueCell = _jsx(Checkbox, { checked: raw === true, focused: selected });
+        }
+        else if (f.type === 'enum' && f.values && f.values.length) {
+            valueCell = (_jsx(Select, { value: String(raw ?? f.values[0]), focused: selected }));
+        }
+        else {
+            valueCell = (_jsx(Text, { color: selected ? UI.text : UI.system, children: displayValue(f, raw, t) }));
+        }
+        items.push(_jsxs(Text, { children: [_jsx(Text, { color: UI.accent, children: selected ? '❯ ' : '  ' }), _jsx(Text, { color: selected ? UI.accent : undefined, bold: selected, children: label }), _jsx(Text, { color: UI.dim, children: '  ' }), valueCell, mod ? _jsx(Text, { color: UI.warn, children: ' ' + mod }) : null, selected ? _jsx(Text, { color: UI.dim, children: '   ' + f.path }) : null] }, 'f' + i));
+    }
+    if (!visible.length) {
+        items.push(_jsx(Text, { color: UI.dim, children: '  ' + t('cfg.menu.no_match') }, "none"));
+    }
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: UI.border, paddingX: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, color: UI.title, children: t('cfg.menu.title') }), _jsx(Text, { color: UI.dim, children: (visible.length ? cursor + 1 : 0) + '/' + visible.length })] }), _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(Math.max(10, (columns || 80) - 6)) }), items, _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(Math.max(10, (columns || 80) - 6)) }), editing ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: UI.text, children: t('cfg.menu.edit_hint') }), _jsx(Text, { color: UI.accent, children: '❯ ' + editBuf })] })) : filterMode ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: UI.text, children: t('cfg.menu.filter_hint') }), _jsx(Text, { color: UI.accent, children: '❯ ' + filterQuery })] })) : message ? (_jsx(Text, { color: UI.ok, children: message })) : filterQuery ? (_jsx(Text, { color: UI.dim, children: t('cfg.menu.filter_active', { q: filterQuery }) })) : null, _jsx(HintBar, { hints: [
+                    ['↑/↓', 'выбор'],
+                    ['←/→', 'изменить'],
+                    ['Enter', 'правка'],
+                    ['/', 'поиск'],
+                    ['d', 'сброс'],
+                    ['q', 'выход'],
+                ] })] }));
+}

package/dist/tui/ConfirmDialog.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// A reusable Ink CONFIRM dialog (y/N) — a small modal box with two buttons
+// navigated by ←/→ (or y/n) and confirmed with Enter. Replaces the raw
+// `promptOnce('... [y/N] ')` that paused the whole TUI.
+import { useState } from 'react';
+import { Box, Text, useInput, useApp } from 'ink';
+import { UI, HintBar } from './widgets.js';
+function Button({ label, focused, danger, }) {
+    const color = danger ? UI.err : UI.on;
+    return (_jsxs(Text, { children: [focused ? _jsx(Text, { color: color, children: '▸ ' }) : _jsx(Text, { children: '  ' }), _jsx(Text, { color: focused ? color : UI.dim, bold: focused, children: label })] }));
+}
+export function ConfirmDialog({ title, message, yesLabel, noLabel, onAnswer, }) {
+    // Focus starts on "no" — a stray Enter must not confirm a destructive action.
+    const [yes, setYes] = useState(false);
+    const { exit } = useApp();
+    const answer = (ok) => {
+        onAnswer(ok);
+        exit();
+    };
+    useInput((input, key) => {
+        if (key.escape || input === 'n' || input === 'N' || input === 'т') {
+            answer(false);
+            return;
+        }
+        if (input === 'y' || input === 'Y' || input === 'д' || input === 'Д') {
+            answer(true);
+            return;
+        }
+        if (key.leftArrow || key.rightArrow || key.tab) {
+            setYes((v) => !v);
+            return;
+        }
+        if (key.return) {
+            answer(yes);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: UI.warn, paddingX: 2, paddingY: 0, children: [_jsx(Text, { color: UI.warn, bold: true, children: '⚠ ' + title }), message ? _jsx(Text, { color: UI.text, children: message }) : null, _jsxs(Box, { marginTop: 1, children: [_jsx(Button, { label: yesLabel, focused: yes, danger: true }), _jsx(Text, { children: '    ' }), _jsx(Button, { label: noLabel, focused: !yes })] }), _jsx(HintBar, { hints: [
+                    ['←/→', 'выбор'],
+                    ['Enter', 'ok'],
+                    ['y/n', ''],
+                ] })] }));
+}

package/dist/tui/FullScreenApp.js

@@ -0,0 +1,113 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The FULL-SCREEN app layout (used when `ui.alternateScreen` is on).
+//
+// Unlike the inline layout (where Ink prints the log as <Static> scrollback),
+// here the WHOLE terminal is ours: a header at the top, a SCROLLABLE log
+// viewport in the middle and the live panel pinned at the bottom. There is no
+// terminal reflow to fight, so a resize never leaves ghost lines — this is the
+// layout Codex / opencode / Claude Code use.
+//
+// Scrolling: the viewport shows the newest content by default (scroll = 0);
+// PgUp/PgDn (and the wheel) move a `scroll` offset in the store.
+import { useSyncExternalStore } from 'react';
+import { Box, Text, useWindowSize, useInput } from 'ink';
+import { LogList } from './LogView.js';
+import { windowByRows, totalRows } from './log-window.js';
+import { StatusBar } from './StatusBar.js';
+import { InputLine } from './InputLine.js';
+import { contentWidth } from '../width.js';
+import { translate } from '../i18n.js';
+import { suggestRowCount } from '../input/suggest.js';
+import { inputBoxRows, truncateToWidth, visLen } from '../input/layout.js';
+import { useMouseWheel } from './useMouseWheel.js';
+/** The header bar: title, version, working directory. */
+function Header({ store }) {
+    const state = useSyncExternalStore(store.subscribe, store.getSnapshot);
+    const cols = Math.max(1, useWindowSize().columns || 80);
+    const right = [state.provider && '[' + state.provider + ']']
+        .filter(Boolean)
+        .join(' ');
+    const left = '❯ ' + state.title + (state.version ? ' v' + state.version : '');
+    const rawDir = state.workdir ? '  ' + state.workdir : '';
+    // The header MUST stay exactly ONE text row: FullScreenApp reserves
+    // HEADER_ROWS = 2 (title + divider) and the whole panel height is computed
+    // from it. A long working directory used to WRAP the title row at a narrow
+    // terminal (or a deep path), adding a third row the layout did not know
+    // about — Ink then overflowed the fixed `height={termRows}` column and the
+    // TOP input row was clipped (the operator saw the second line overprint the
+    // first). Truncate the directory (then the title) so the row always fits.
+    const gap = Math.max(1, cols - visLen(left) - visLen(rawDir) - visLen(right) - 2);
+    let dir = rawDir;
+    const budget = cols - visLen(left) - visLen(right) - 2;
+    if (visLen(dir) > budget)
+        dir = budget > 0 ? truncateToWidth(dir, budget) : '';
+    // If even title + provider exceed the width, drop the directory entirely.
+    const finalDir = gap >= 1 ? dir : '';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "#c8b06a", bold: true, children: left }), _jsx(Text, { color: "#7fc4f0", children: finalDir }), _jsx(Text, { children: ' '.repeat(Math.max(1, cols - visLen(left) - visLen(finalDir) - visLen(right) - 2)) }), right ? _jsx(Text, { color: "#6fd0b0", children: right }) : null] }), _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(cols) })] }));
+}
+export function FullScreenApp({ store, inputProps, }) {
+    const state = useSyncExternalStore(store.subscribe, store.getSnapshot);
+    const { rows } = useWindowSize();
+    const termRows = rows || 24;
+    // Fixed panel height: header (2) + status (1) + the input box (2 borders +
+    // its VISUAL rows) + the suggestion popup rows. The log viewport gets the
+    // rest.
+    const HEADER_ROWS = 2;
+    const STATUS_ROWS = 1;
+    const cols = Math.max(1, useWindowSize().columns || 80);
+    // The box height comes from the SAME layoutInput() the box renders with, so
+    // the reserved rows and the drawn rows can never disagree (a logical-line
+    // count missed the word-wrap of a long line and the second line overprinted
+    // the first).
+    const INPUT_BOX_ROWS = inputBoxRows(state.prompt, state.edit.buf, state.edit.cursor, cols);
+    // The suggestion popup renders ABOVE the input box; reserve its rows so
+    // opening the list does not push the panel / shift the whole layout.
+    const suggestRows = suggestRowCount(state.edit.buf, state.commands, cols);
+    const panelRows = HEADER_ROWS + STATUS_ROWS + INPUT_BOX_ROWS + suggestRows;
+    const logHeight = Math.max(1, termRows - panelRows);
+    // Window the log BY RENDERED ROW: a long wrapped answer can be taller than
+    // one entry, and an entry-count window either overflowed the panel or left
+    // it half empty. `scroll` is measured in ROWS here (0 = newest at the
+    // bottom).
+    const all = state.log;
+    const total = totalRows(all, cols);
+    const maxScroll = Math.max(0, total - logHeight);
+    const scroll = Math.max(0, Math.min(state.scroll, maxScroll));
+    const visible = windowByRows(all, logHeight, scroll, cols);
+    // Scroll the log with PgUp/PgDn; Home/End jump to the very top/bottom. The
+    // input line OWNS Home/End while its buffer is non-empty (they move the
+    // caret), so the jump only applies to an EMPTY buffer — which is exactly
+    // when the operator is navigating the log to select a large block.
+    //
+    // `useInput` binds the callback ONCE, so a `scroll` captured in the closure
+    // goes STALE after the first scroll (PgUp/PgDn/Home/End then compute from an
+    // old offset and jump wrong). Read the live value from the store instead.
+    useInput((_input, key) => {
+        const step = Math.max(1, Math.floor(logHeight / 2));
+        const cur = store.getSnapshot().scroll;
+        if (key.pageUp) {
+            store.set({ scroll: Math.min(maxScroll, cur + step) });
+        }
+        else if (key.pageDown) {
+            store.set({ scroll: Math.max(0, cur - step) });
+        }
+        else if (state.edit.buf.length === 0 && (key.home || key.end)) {
+            // Both the bare and the Ctrl-modified forms land here (Ink sets
+            // key.end / key.home for either), so Ctrl+End / Ctrl+Home are a
+            // reliable fallback on terminals that swallow the bare keys.
+            store.set({ scroll: key.home ? maxScroll : 0 });
+        }
+    });
+    // Scroll the log with the MOUSE WHEEL. Ink does not parse mouse events, so
+    // useMouseWheel reads the raw SGR sequences (see the hook). One wheel notch
+    // scrolls ~3 rows, like most terminals.
+    useMouseWheel((delta) => {
+        const cur = store.getSnapshot().scroll;
+        const next = cur + delta * 3;
+        store.set({ scroll: Math.max(0, Math.min(maxScroll, next)) });
+    }, state.mouseScroll);
+    return (_jsxs(Box, { flexDirection: "column", height: termRows, children: [_jsx(Header, { store: store }), _jsx(Box, { flexDirection: "column", height: logHeight, overflow: "hidden", justifyContent: "flex-end", children: all.length === 0 ? (_jsx(Text, { color: "#5b616e", children: translate(state.locale)('editor.empty_hint') })) : (_jsx(LogList, { entries: visible })) }), _jsx(StatusBar, { state: state, divider: false }), _jsx(InputLine, { ...inputProps, store: store, 
+                // Cursor rows above the input box: header + log viewport + status.
+                cursorTop: HEADER_ROWS + logHeight + suggestRows + STATUS_ROWS + 1, prompt: state.prompt, locale: state.locale, commands: state.commands, locked: state.locked })] }));
+}
+void contentWidth;