zames_pro 2.73.10 → 2.74.0

package/dist/tui/ConfigMenu.js

@@ -0,0 +1,304 @@
+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);
+    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);
+            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');
+            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);
+        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');
+            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);
+                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, accounting for group headers.
+    const termRows = rows || 24;
+    const maxItemRows = Math.max(3, termRows - 6);
+    const shown = useMemo(() => {
+        // Walk back from the cursor until the window would overflow.
+        let start = Math.min(cursor, Math.max(0, visible.length - 1));
+        const groupStart = (i) => i === 0 || visible[i].groupKey !== visible[i - 1].groupKey;
+        const rowsFor = (from) => {
+            let r = 0;
+            for (let i = from; i <= cursor; i++) {
+                if (i === from || groupStart(i))
+                    r++;
+                r++;
+            }
+            return r;
+        };
+        while (start > 0 && rowsFor(start - 1) <= maxItemRows)
+            start--;
+        return { start, end: Math.min(visible.length, start + maxItemRows) };
+    }, [cursor, visible, maxItemRows]);
+    const usable = Math.max(1, (columns || 80) - 1);
+    void visCols;
+    void usable;
+    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,85 @@
+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 } 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 dir = state.workdir ? '  ' + state.workdir : '';
+    const gap = Math.max(1, cols - left.length - dir.length - right.length - 2);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "#c8b06a", bold: true, children: left }), _jsx(Text, { color: "#7fc4f0", children: dir }), _jsx(Text, { children: ' '.repeat(gap) }), 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);
+    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.
+    useInput((_input, key) => {
+        const step = Math.max(1, Math.floor(logHeight / 2));
+        if (key.pageUp) {
+            store.set({ scroll: Math.min(maxScroll, scroll + step) });
+        }
+        else if (key.pageDown) {
+            store.set({ scroll: Math.max(0, scroll - step) });
+        }
+    });
+    // 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 next = scroll + 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;