zames_pro 2.5.1 → 2.6.0

package/README.md

@@ -60,6 +60,38 @@ zames --help
 Global config: `~/.zames/config.json`
 Local (per project): `.zamesrc.json`
 
+You can view and change settings without leaving the agent — use the
+`/config` command. Run it without arguments to open an interactive menu
+(↑/↓ to move, Enter to change, `d` to reset, `q` to quit). Booleans and enums
+toggle in place; numbers and strings open an input prompt.
+
+```
+/config                       interactive settings menu
+/config list                  print all editable settings
+/config get <path>            show a setting
+/config set <path> <value>    change a setting
+/config reset <path>          reset a setting to its default
+/config path                  show config file paths
+/config lang <ru|en>          switch interface and agent language
+```
+
+Examples:
+
+```
+/config set maxIterations 20
+/config set confirmation.bash false
+/config lang en
+```
+
+Changes are written to the project `.zamesrc.json` and applied right away
+(where possible without a restart).
+
+### Language
+
+`/config lang ru` or `/config lang en` switches both the interface language
+(help, messages, spinner) and the language the agent answers you in. The
+locale lives in `ui.locale` in the config file.
+
 Agent data is stored in `~/.zames`: browser profile, logs, undo history, self-review snapshots.
 
 ## License

package/dist/agent-loop.js

@@ -1,7 +1,7 @@
 import { buildSystemPrompt } from './system-prompt.js';
 import { getGitContext, formatGitContext } from './gitTools.js';
 import { parseXmlToolCalls } from './xml-toolcall.js';
-export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 40, freshChat = false, sendSystemPrompt = false, transcript = null, onThinking = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, debugLog = false, }) {
+export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 40, freshChat = false, sendSystemPrompt = false, transcript = null, onThinking = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, debugLog = false, locale = 'ru', }) {
     if (freshChat) {
         await browser.newChat();
         transcript?.log('new_chat');
@@ -35,6 +35,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             workdir,
             tools,
             gitContext: gitText,
+            locale,
         });
         transcript?.log('system_prompt', {
             length: systemPrompt.length,
@@ -90,10 +91,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             // только явный JSON, но и XML/DSML-формы, «грязные» варианты и
             // незакрытые фрагменты: если такой ответ молча принять за финальный,
             // агент встанет, хотя модель пыталась позвать инструмент.
-            const looksLikeToolCall = /("tool"\s*:|\btool_calls?\b|\binvoke\b|\bparameter\b|DSML|function_call)/i.test(rawResponse) ||
-                /\{\s*"?(tool|name|args)"?\s*:/.test(rawResponse) ||
-                /<\s*\|?\s*(DSML|invoke|parameter)/i.test(rawResponse) ||
-                /^\s*\[?\s*\{[^}]*$/.test(rawResponse.trim());
+            const looksLikeToolCall = responseLooksLikeToolCall(rawResponse);
             if (looksLikeToolCall && malformedRetries < MAX_MALFORMED_RETRIES) {
                 malformedRetries++;
                 transcript?.log('malformed_toolcall', {
@@ -245,6 +243,31 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     }
     return 'Достигнут лимит итераций.';
 }
+// Ответ похож на вызов инструмента, но parseToolCall() его не распознал.
+// Используется как страховка от «агент вызвал инструмент и остановился»:
+// в этом случае runAgentLoop просит модель переотправить вызов, а не
+// завершает задачу. Ловим и явные форматы, и «поломанные» головы вызова
+// (`<｜tool": ...`, `**tool**:`, `tool": ...`), и обрезанные вызовы.
+export function responseLooksLikeToolCall(rawResponse) {
+    const raw = rawResponse || '';
+    return (
+    // Явные маркеры форматов tool-call: JSON-ключ "tool", XML/DSML-теги,
+    // function_call и т.п.
+    /("tool"\s*:|\btool_calls?\b|\binvoke\b|\bparameter\b|DSML|function_call)/i.test(raw) ||
+        // «tool» без открывающей кавычки/скобки, с мусорным префиксом
+        // (`<｜tool":`, `**tool**:`, `- tool:`): ключ вызова, а не проза.
+        /(^|[^A-Za-z0-9_])(?:\*\*)?tool(?:\*\*)?["'`\u2018\u2019\u201c\u201d]*\s*:/.test(raw) ||
+        // Ключи в одинарных кавычках или без кавычек: {'tool': 'Read', ...}.
+        /[\{\[]\s*['"]?(tool|name|args)['"]?\s*:/.test(raw) ||
+        // Обрезанный вызов: начинается как JSON-объект, но не закрыт, и в нём
+        // есть ключ аргумента (args/command/path/...). Требуем именно открывающую
+        // скобку в начале (после пробелов/префикса), чтобы не ловить обычную
+        // прозу с двоеточиями вроде «path: ...».
+        /^\s*[\[\{]/.test(raw) &&
+            /["']?(?:tool|args|command|path|old_string|content|content_base64)["']?\s*:/.test(raw) ||
+        /<\s*\|?\s*(DSML|invoke|parameter)/i.test(raw) ||
+        /^\s*\[?\s*\{[^}]*$/.test(raw.trim()));
+}
 // Текст, который обещает вызов инструмента в будущем времени, но самого
 // вызова не содержит. DeepSeek регулярно так «зависает»: пишет
 // «Now update README to mention …», «Let me run the tests», «Сейчас проверю»
@@ -699,6 +722,81 @@ function findMatching(text, openIdx, openCh, closeCh) {
     }
     return -1;
 }
+// Модель иногда отдаёт вызов инструмента с ключами/строками в одинарных
+// кавычках («{'tool': 'Read', 'args': {...}}») или с ключами без кавычек
+// («{tool: "Read", args: {...}}»). Это не валидный JSON, и без нормализации
+// такой ответ молча принимается за финальный — агент встаёт, не вызвав
+// инструмент. Приводим его к двойным кавычкам.
+function normalizePseudoJson(str) {
+    // Ключи без кавычек: {tool: ...} или , args: ... → "tool": / "args":
+    let out = str.replace(/([\{\[]\s*)([A-Za-z_][A-Za-z0-9_]*)\s*:/g, '$1"$2":');
+    out = out.replace(/,\s*([A-Za-z_][A-Za-z0-9_]*)\s*:/g, ', "$1":');
+    // Одинарные кавычки → двойные. Не трогаем содержимое уже двойных строк,
+    // идущее подряд, и экранируем случайные двойные внутри одинарных.
+    let res = '';
+    let inDouble = false;
+    let inSingle = false;
+    for (let i = 0; i < out.length; i++) {
+        const c = out[i];
+        if (c === '\\' && (inDouble || inSingle)) {
+            res += c;
+            if (i + 1 < out.length) {
+                res += out[i + 1];
+                i++;
+            }
+            continue;
+        }
+        if (c === '"' && !inSingle) {
+            inDouble = !inDouble;
+            res += c;
+            continue;
+        }
+        if (c === "'" && !inDouble) {
+            if (!inSingle) {
+                inSingle = true;
+                res += '"';
+            }
+            else {
+                inSingle = false;
+                res += '"';
+            }
+            continue;
+        }
+        if (inSingle && c === '"') {
+            res += '\\"';
+            continue;
+        }
+        res += c;
+    }
+    return res;
+}
+// Модель иногда портит начало вызова: `<｜tool": "Bash", "args": {...}`,
+// `tool": "Read", ...`, `**tool**: ...`, `- tool: ...`. В таких ответах
+// нет открывающей `{`, а ключ `tool` лишился первой кавычки. Если такой
+// ответ принять за финальный, агент молча встанет (частая «остановка»).
+// Восстанавливаем: срезаем мусорный префикс до слова tool, добавляем `{` и
+// доводим кавычки ключа до парных.
+function repairToolCallPreamble(text) {
+    const t = (text || '').trim();
+    const m = t.match(/(?:^|[^A-Za-z0-9_])(?:\*\*)?(tool)(?:\*\*)?["'`\u2018\u2019\u201c\u201d]*\s*:/);
+    if (!m || m.index === undefined)
+        return null;
+    // Начало ищем с первой кавычки/скобки вокруг ключа, иначе — с слова tool.
+    let start = m.index;
+    const brace = t.indexOf('{', Math.max(0, start - 1));
+    if (brace !== -1 && brace < start)
+        start = brace;
+    let frag = t.slice(start);
+    // Если фрагмент не начинается с `{` — добавляем его.
+    if (!frag.startsWith('{')) {
+        // Ключ мог потерять открывающую кавычку: tool": → "tool":.
+        // Срезаем ведущий мусор до слова tool и нормализуем кавычки ключа.
+        frag = frag.replace(/^[^A-Za-z0-9_]*/, '');
+        frag = frag.replace(/^(?:\*\*)?(["'`\u2018\u2019\u201c\u201d]*)(tool)(?:\*\*)?["'`\u2018\u2019\u201c\u201d]*\s*:/, '"$2":');
+        frag = '{' + frag;
+    }
+    return frag;
+}
 export function parseToolCall(text) {
     if (!text || typeof text !== 'string')
         return null;
@@ -731,8 +829,24 @@ export function parseToolCall(text) {
         if (ctrlArr)
             return ctrlArr;
     }
+    // Псевдо-JSON (одинарные кавычки / ключи без кавычек) — нормализуем и
+    // пробуем распарсить как обычный вызов, прежде чем идти в permissive.
+    if (/['"]?tool['"]?\s*:/.test(cleaned)) {
+        const norm = normalizePseudoJson(cleaned);
+        if (norm !== cleaned) {
+            for (const raw of extractJsonObjects(norm)) {
+                const a = tryParseArray(raw);
+                if (a)
+                    return a;
+                const o = tryParse(raw);
+                if (o)
+                    return o;
+            }
+        }
+    }
     const permissive = parseToolCallPermissive(cleaned) ||
-        parseToolCallPermissive(repairRawControlChars(cleaned));
+        parseToolCallPermissive(repairRawControlChars(cleaned)) ||
+        parseToolCallPermissive(normalizePseudoJson(cleaned));
     if (permissive)
         return { ...permissive, _permissive: true };
     const toolIdx = cleaned.search(/["']?tool["']?\s:/);
@@ -747,6 +861,31 @@ export function parseToolCall(text) {
     const xmlCalls = parseXmlToolCalls(cleaned);
     if (xmlCalls)
         return Array.isArray(xmlCalls) ? xmlCalls : [xmlCalls];
+    // Последняя попытка: «починить» испорченную голову вызова (`<｜tool": ...`,
+    // `tool": ...`, `**tool**: ...`, `- tool: ...`). Делаем это ТОЛЬКО как
+    // fallback, после обычного разбора — иначе легко испортить валидный JSON
+    // (например, массив вызовов начинается с `[`, внутри которого `{"tool":`).
+    const preamble = repairToolCallPreamble(cleaned);
+    if (preamble && preamble !== cleaned) {
+        const reps = [
+            preamble,
+            repairRawControlChars(preamble),
+            normalizePseudoJson(preamble),
+        ];
+        for (const rep of reps) {
+            for (const raw of extractJsonObjects(rep)) {
+                const a = tryParseArray(raw);
+                if (a)
+                    return a;
+                const o = tryParse(raw);
+                if (o)
+                    return o;
+            }
+        }
+        const perm = parseToolCallPermissive(preamble);
+        if (perm)
+            return { ...perm, _permissive: true };
+    }
     return null;
 }
 function extractPreToolText(text) {

package/dist/browser.js

@@ -506,7 +506,7 @@ export class DeepSeekBrowser {
         const gap = this.minSendIntervalMs - (Date.now() - this._lastSentAt);
         if (gap <= 0)
             return;
-        console.error(theme.warn(`⏳ пауза ${Math.ceil(gap / 1000)}с перед отправкой...`));
+        console.error(theme.warn(`⏳ пауза ${Math.ceil(gap / 1000)}с перед отправкой`));
         await this.page.waitForTimeout(gap);
     }
     async _askOnce(prompt, { timeout, agent }) {

package/dist/config-menu.js

@@ -0,0 +1,231 @@
+// Интерактивное меню настроек для команды /config.
+//
+// Меню рисует список параметров, сгруппированных по секциям, и позволяет
+// менять их стрелками: boolean/enum переключаются на месте, number/string
+// запрашивают ввод. Все строки берутся из i18n (cfg.*), поэтому меню
+// полностью локализовано.
+//
+// Модуль не знает про config.ts напрямую (кроме типов схемы): чтение и
+// запись значений делает вызывающий через колбэки. Так меню легко тестировать
+// и переиспользовать.
+import { theme } from './theme.js';
+const ESC = String.fromCharCode(27);
+// Убираем ANSI-последовательности, чтобы посчитать видимую длину строки.
+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);
+}
+/**
+ * Показать интерактивное меню. Возвращает промис, который резолвится, когда
+ * пользователь вышел (q/Esc/Ctrl+C). В не-TTY бросает ошибку — вызывающий
+ * должен показать текстовый список.
+ */
+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'); // прячем курсор на время отрисовки
+    // Отрисовка меню: строки идут сверху вниз, курсор возвращаем в начало
+    // блока через относительные перемещения, чтобы не плодить пустые строки.
+    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')));
+        }
+        // Стираем прошлый блок и печатаем новый. Считаем ВИЗУАЛЬНЫЕ строки
+        // (с учётом переноса по ширине терминала), иначе на узких терминалах
+        // остаётся «мусор» из нестёртых хвостов.
+        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'); // возвращаем курсор
+        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 — запрашиваем ввод.
+        editing = true;
+        editBuf = get(f.path) === undefined ? '' : String(get(f.path));
+    };
+    const onData = (buf) => {
+        const s = buf.toString('utf-8');
+        if (editing) {
+            // Обрабатываем ввод посимвольно: терминал может прислать несколько
+            // байт сразу (вставка, авто-повтор), Enter — 0x0d/0x0a, backspace — 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;
+        }
+        // Терминал может прислать несколько клавиш одним пакетом (быстрый набор,
+        // авто-повтор, автоматизация). Разбираем буфер по токенам: сначала
+        // escape-последовательности (стрелки), затем одиночные символы.
+        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;
+}
+/**
+ * Прочитать только тот файл конфига, что указан (без слияния с дефолтами),
+ * чтобы запись не «замораживала» все дефолты в файле пользователя.
+ */
+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 {};
+}
+/**
+ * Записать значение настройки в файл. Возвращает итоговый объект, который
+ * лёг в файл. Значение сперва валидируется по схеме.
+ */
+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 };
+}
+/** Сбросить настройку к дефолту (удалить ключ из файла). */
+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 };