zames_pro 2.5.1 → 2.7.0

package/dist/config-menu.js

@@ -0,0 +1,231 @@
+// Interactive settings menu for the /config command.
+//
+// The menu renders a list of parameters grouped by sections and lets you
+// change them with the arrow keys: boolean/enum toggle in place, number/string
+// prompt for input. All strings come from i18n (cfg.*), so the menu is
+// fully localized.
+//
+// The module doesn't know about config.ts directly (except for the schema
+// types): the caller reads and writes values through callbacks. This makes the
+// menu easy to test and reuse.
+import { theme } from './theme.js';
+const ESC = String.fromCharCode(27);
+// Strip ANSI sequences to compute the visible length of a line.
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '');
+}
+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');
+    return String(value);
+}
+function groupLabel(field, t) {
+    return t(field.groupKey);
+}
+/**
+ * Show the interactive menu. Returns a promise that resolves when the
+ * user exits (q/Esc/Ctrl+C). In a non-TTY it throws — the caller
+ * must show a text list.
+ */
+export function runConfigMenu(opts) {
+    const input = opts.input || process.stdin;
+    const output = opts.output || process.stdout;
+    const { fields, t, get, set, reset } = opts;
+    if (!input.isTTY || !input.setRawMode) {
+        return Promise.reject(new Error(t('cfg.menu.notty')));
+    }
+    let cursor = 0;
+    let editing = false;
+    let editBuf = '';
+    let message = null;
+    let exited = false;
+    let resolveDone = null;
+    const wasRaw = input.isRaw;
+    input.setRawMode(true);
+    input.resume();
+    output.write(ESC + '[?25l'); // hide the cursor while rendering
+    // Menu rendering: lines go top to bottom, and we return the cursor to the
+    // start of the block via relative moves so we don't spawn blank lines.
+    let lastRows = 0;
+    const render = () => {
+        const lines = [];
+        lines.push(theme.bold(t('cfg.menu.title')));
+        let lastGroup = '';
+        for (let i = 0; i < fields.length; i++) {
+            const f = fields[i];
+            const g = groupLabel(f, t);
+            if (g !== lastGroup) {
+                lines.push(theme.system('  ' + g));
+                lastGroup = g;
+            }
+            const selected = i === cursor;
+            const marker = selected ? theme.prompt('\u276f ') : '  ';
+            const label = selected ? theme.prompt(f.labelKey ? t(f.labelKey) : f.path) : t(f.labelKey || f.path);
+            const val = displayValue(f, get(f.path), t);
+            const valText = selected ? theme.assistant(val) : theme.dim(val);
+            const pathText = selected ? theme.dim('  ' + f.path) : '';
+            lines.push(marker + label + theme.dim('  =  ') + valText + pathText);
+        }
+        if (editing) {
+            lines.push('');
+            lines.push(theme.user(t('cfg.menu.edit_hint')));
+            lines.push(theme.prompt('\u276f ') + editBuf);
+        }
+        else if (message) {
+            lines.push('');
+            lines.push(theme.assistant(message));
+        }
+        else {
+            lines.push('');
+            lines.push(theme.dim(t('cfg.menu.hint')));
+        }
+        // Erase the previous block and print the new one. We count VISUAL lines
+        // (accounting for wrapping by terminal width), otherwise on narrow
+        // terminals you get "garbage" from unerased tails.
+        const cols = output.columns || 80;
+        const rowsOf = (s) => {
+            const len = stripAnsi(s).length;
+            return Math.max(1, Math.ceil(len / Math.max(1, cols)));
+        };
+        if (lastRows > 0) {
+            output.write(ESC + '[' + lastRows + 'A');
+            for (let i = 0; i < lastRows; i++) {
+                output.write(ESC + '[2K' + ESC + '[1B');
+            }
+            output.write(ESC + '[' + lastRows + 'A');
+        }
+        output.write(lines.join('\n') + '\n');
+        lastRows = lines.reduce((n, l) => n + rowsOf(l), 0);
+    };
+    const cleanup = () => {
+        if (exited)
+            return;
+        exited = true;
+        input.removeListener('data', onData);
+        if (input.setRawMode)
+            input.setRawMode(wasRaw || false);
+        output.write(ESC + '[?25h'); // restore the cursor
+        if (resolveDone)
+            resolveDone();
+    };
+    const commitEdit = () => {
+        const f = fields[cursor];
+        const raw = editBuf.trim();
+        editing = false;
+        editBuf = '';
+        if (!raw) {
+            message = null;
+            return;
+        }
+        try {
+            set(f, raw);
+            message = t('cfg.menu.saved', {
+                v: f.path,
+                value: displayValue(f, get(f.path), t),
+            });
+        }
+        catch (e) {
+            message = String(e.message || e);
+        }
+    };
+    const toggle = () => {
+        const f = fields[cursor];
+        if (f.type === 'boolean') {
+            const cur = get(f.path);
+            set(f, cur === true ? 'false' : 'true');
+            message = null;
+            return;
+        }
+        if (f.type === 'enum' && f.values && f.values.length) {
+            const cur = String(get(f.path) ?? '');
+            const idx = f.values.indexOf(cur);
+            const next = f.values[(idx + 1) % f.values.length];
+            set(f, next);
+            message = null;
+            return;
+        }
+        // number/string — prompt for input.
+        editing = true;
+        editBuf = get(f.path) === undefined ? '' : String(get(f.path));
+    };
+    const onData = (buf) => {
+        const s = buf.toString('utf-8');
+        if (editing) {
+            // Process input character by character: the terminal may send several
+            // bytes at once (paste, auto-repeat), Enter is 0x0d/0x0a, backspace is 0x7f.
+            for (const ch of s) {
+                if (ch === '\r' || ch === '\n') {
+                    commitEdit();
+                    break;
+                }
+                if (ch === ESC) {
+                    editing = false;
+                    editBuf = '';
+                    break;
+                }
+                if (ch === '\x03') {
+                    cleanup();
+                    output.write('\n');
+                    return;
+                }
+                if (ch === '\x7f' || ch === '\b') {
+                    editBuf = editBuf.slice(0, -1);
+                }
+                else if (ch >= ' ') {
+                    editBuf += ch;
+                }
+            }
+            render();
+            return;
+        }
+        // The terminal may send several keys in one packet (fast typing,
+        // auto-repeat, automation). We parse the buffer into tokens: first
+        // escape sequences (arrows), then single characters.
+        let i = 0;
+        while (i < s.length) {
+            if (s.startsWith('\x1b[A', i)) {
+                cursor = (cursor - 1 + fields.length) % fields.length;
+                message = null;
+                i += 3;
+                continue;
+            }
+            if (s.startsWith('\x1b[B', i)) {
+                cursor = (cursor + 1) % fields.length;
+                message = null;
+                i += 3;
+                continue;
+            }
+            const ch = s[i];
+            if (ch === 'q' || ch === 'Q' || ch === '\x03' || ch === ESC) {
+                cleanup();
+                output.write('\n');
+                return;
+            }
+            if (ch === 'k') {
+                cursor = (cursor - 1 + fields.length) % fields.length;
+                message = null;
+            }
+            else if (ch === 'j') {
+                cursor = (cursor + 1) % fields.length;
+                message = null;
+            }
+            else if (ch === '\r' || ch === '\n' || ch === ' ') {
+                toggle();
+            }
+            else if (ch === 'd' || ch === 'D') {
+                const f = fields[cursor];
+                reset(f);
+                message = t('cfg.reset', { v: f.path });
+            }
+            i++;
+        }
+        render();
+    };
+    return new Promise((resolve) => {
+        resolveDone = resolve;
+        input.on('data', onData);
+        render();
+    });
+}

package/dist/config.js

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { DEFAULT_LOCALE } from './i18n.js';
 const ZAMES_HOME = path.join(os.homedir(), '.zames');
 const HOME_CONFIG = path.join(ZAMES_HOME, 'config.json');
 const PROJECT_CONFIG = path.join(process.cwd(), '.zamesrc.json');
@@ -41,6 +42,9 @@ export const DEFAULTS = {
         rateLimitWaitMs: 300000,
         maxRateLimitRetries: 6,
     },
+    ui: {
+        locale: DEFAULT_LOCALE,
+    },
 };
 export function loadConfig() {
     const merged = JSON.parse(JSON.stringify(DEFAULTS));
@@ -71,5 +75,144 @@ function deepMerge(target, source) {
         }
     }
 }
+export const CONFIG_SCHEMA = [
+    { path: 'ui.locale', type: 'enum', values: ['ru', 'en'], labelKey: 'cfg.f.ui_locale', groupKey: 'cfg.group.ui' },
+    { path: 'maxIterations', type: 'number', min: 1, max: 1000, labelKey: 'cfg.f.maxIterations', groupKey: 'cfg.group.agent' },
+    { path: 'headless', type: 'boolean', labelKey: 'cfg.f.headless', groupKey: 'cfg.group.agent' },
+    { path: 'debug', type: 'boolean', labelKey: 'cfg.f.debug', groupKey: 'cfg.group.agent' },
+    { path: 'hotReload', type: 'boolean', labelKey: 'cfg.f.hotReload', groupKey: 'cfg.group.agent' },
+    { path: 'confirmation.write', type: 'boolean', labelKey: 'cfg.f.confirmation_write', groupKey: 'cfg.group.confirmation' },
+    { path: 'confirmation.edit', type: 'boolean', labelKey: 'cfg.f.confirmation_edit', groupKey: 'cfg.group.confirmation' },
+    { path: 'confirmation.bash', type: 'boolean', labelKey: 'cfg.f.confirmation_bash', groupKey: 'cfg.group.confirmation' },
+    { path: 'undo.enabled', type: 'boolean', labelKey: 'cfg.f.undo_enabled', groupKey: 'cfg.group.undo' },
+    { path: 'undo.maxBackups', type: 'number', min: 1, max: 100000, labelKey: 'cfg.f.undo_maxBackups', groupKey: 'cfg.group.undo' },
+    { path: 'transcript.enabled', type: 'boolean', labelKey: 'cfg.f.transcript_enabled', groupKey: 'cfg.group.transcript' },
+    { path: 'browser.answerTimeoutMs', type: 'number', min: 1000, max: 3600000, labelKey: 'cfg.f.browser_answerTimeoutMs', groupKey: 'cfg.group.browser' },
+    { path: 'browser.askRetries', type: 'number', min: 1, max: 100, labelKey: 'cfg.f.browser_askRetries', groupKey: 'cfg.group.browser' },
+    { path: 'browser.stabilityChecks', type: 'number', min: 1, max: 100, labelKey: 'cfg.f.browser_stabilityChecks', groupKey: 'cfg.group.browser' },
+    { path: 'browser.stabilityDelayMs', type: 'number', min: 0, max: 60000, labelKey: 'cfg.f.browser_stabilityDelayMs', groupKey: 'cfg.group.browser' },
+    { path: 'browser.minSendIntervalMs', type: 'number', min: 0, max: 600000, labelKey: 'cfg.f.browser_minSendIntervalMs', groupKey: 'cfg.group.browser' },
+    { path: 'browser.rateLimitWaitMs', type: 'number', min: 0, max: 3600000, labelKey: 'cfg.f.browser_rateLimitWaitMs', groupKey: 'cfg.group.browser' },
+    { path: 'browser.maxRateLimitRetries', type: 'number', min: 0, max: 100, labelKey: 'cfg.f.browser_maxRateLimitRetries', groupKey: 'cfg.group.browser' },
+];
+export function getConfigField(path) {
+    return CONFIG_SCHEMA.find((f) => f.path === path);
+}
+export function getByPath(obj, path) {
+    const parts = path.split('.');
+    let cur = obj;
+    for (const p of parts) {
+        if (cur === null || cur === undefined || typeof cur !== 'object') {
+            return undefined;
+        }
+        cur = cur[p];
+    }
+    return cur;
+}
+export function setByPath(obj, path, value) {
+    const parts = path.split('.');
+    let cur = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const p = parts[i];
+        if (typeof cur[p] !== 'object' || cur[p] === null)
+            cur[p] = {};
+        cur = cur[p];
+    }
+    cur[parts[parts.length - 1]] = value;
+}
+function parseConfigValue(field, raw) {
+    switch (field.type) {
+        case 'boolean': {
+            const s = raw.trim().toLowerCase();
+            if (['true', '1', 'yes', 'y', 'on', 'да', 'вкл'].includes(s))
+                return true;
+            if (['false', '0', 'no', 'n', 'off', 'нет', 'выкл'].includes(s))
+                return false;
+            throw new Error('boolean');
+        }
+        case 'number': {
+            const n = Number(raw);
+            if (!Number.isFinite(n))
+                throw new Error('number');
+            if (field.min !== undefined && n < field.min)
+                throw new Error('number');
+            if (field.max !== undefined && n > field.max)
+                throw new Error('number');
+            return n;
+        }
+        case 'enum': {
+            const s = raw.trim().toLowerCase();
+            if (field.values && !field.values.includes(s))
+                throw new Error('enum');
+            return s;
+        }
+        default:
+            return raw;
+    }
+}
+export function validateConfigValue(field, raw) {
+    return parseConfigValue(field, raw);
+}
+export function configPathFor(scope) {
+    return scope === 'project' ? PROJECT_CONFIG : HOME_CONFIG;
+}
+/**
+ * Read only the specified config file (without merging with defaults), so that
+ * writing does not "freeze" all defaults into the user's file.
+ */
+export function readConfigFile(file) {
+    try {
+        const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        if (data && typeof data === 'object' && !Array.isArray(data)) {
+            return data;
+        }
+    }
+    catch (e) {
+        const err = e;
+        if (err.code !== 'ENOENT') {
+            throw new Error(`не удалось прочитать ${file}: ${err.message}`);
+        }
+    }
+    return {};
+}
+/**
+ * Write a setting value to the file. Returns the final object that was
+ * written. The value is first validated against the schema.
+ */
+export function writeConfigValue(scope, key, raw) {
+    const field = getConfigField(key);
+    if (!field)
+        throw new Error(`unknown setting: ${key}`);
+    const value = parseConfigValue(field, raw);
+    const file = configPathFor(scope);
+    const data = readConfigFile(file);
+    setByPath(data, key, value);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+    return { value, file };
+}
+/** Reset a setting to the default (remove the key from the file). */
+export function resetConfigValue(scope, key) {
+    const field = getConfigField(key);
+    if (!field)
+        throw new Error(`unknown setting: ${key}`);
+    const file = configPathFor(scope);
+    const data = readConfigFile(file);
+    const parts = key.split('.');
+    let cur = data;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const p = parts[i];
+        if (!cur || typeof cur[p] !== 'object' || cur[p] === null) {
+            cur = undefined;
+            break;
+        }
+        cur = cur[p];
+    }
+    if (cur)
+        delete cur[parts[parts.length - 1]];
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+    return file;
+}
 export const CONFIG_PATHS = { HOME_CONFIG, PROJECT_CONFIG };
 export { ZAMES_HOME };

package/dist/gitTools.js

@@ -36,8 +36,8 @@ export function runGit(cmd, cwd, timeout = 15_000) {
         });
     });
 }
-// Безопасно квотит пути/аргументы для передачи в shell.
-// Строка или массив -> строка с двойными кавычками и экранированием.
+// Safely quotes paths/arguments for passing to the shell.
+// String or array -> a string with double quotes and escaping.
 function quoteArgs(input) {
     const list = Array.isArray(input) ? input : [input];
     return list
@@ -46,7 +46,7 @@ function quoteArgs(input) {
         .map((v) => JSON.stringify(v))
         .join(' ');
 }
-// Проверяет, является ли директория git-репозиторием, и собирает контекст.
+// Checks whether the directory is a git repository and gathers the context.
 export async function getGitContext(workdir) {
     const probe = await runGit('git rev-parse --is-inside-work-tree', workdir, 5000);
     if (probe.trim() !== 'true')
@@ -175,7 +175,7 @@ export function createGitTools(workdir) {
                 if (!msg.trim()) {
                     return 'Ошибка: message пустой.';
                 }
-                // Индексируем всё только если в индексе пусто (как обещает описание).
+                // We stage everything only if the index is empty (as the description promises).
                 const staged = await runGit('git diff --cached --name-only', workdir, 10_000);
                 const hasStaged = !/^\s*/.test(staged) &&
                     staged.trim() !== '(команда выполнена, вывода нет)';