zames_pro 2.29.16 → 2.32.0

package/dist/commands.js

@@ -1,4 +1,5 @@
 import path from 'path';
+import { isImageName } from './attachments.js';
 // Helpers for the extra slash commands (/diff, /cost, /export, /doctor,
 // /permissions, /review, /add-dir). Pure functions, unit-tested without a
 // live agent/browser. index.ts only renders their output.
@@ -168,6 +169,15 @@ export function renderDoctor(d) {
     row(!!d.clipboardTool, 'clipboard', d.clipboardTool || 'no tool found (image paste disabled)');
     row(true, 'mcp', d.mcpServers + ' server(s), ' + d.mcpTools + ' tool(s)');
     row(d.transcriptOk, 'transcript', d.transcriptOk ? 'on' : 'off');
+    if (typeof d.contextLimit === 'number' && d.contextLimit > 0) {
+        row(true, 'context', d.contextLimit.toLocaleString('en-US') + ' tokens');
+    }
+    if (d.gitOk && typeof d.hasOrigin === 'boolean') {
+        row(true, 'git remote', d.hasOrigin ? 'origin configured' : 'no origin');
+    }
+    if (typeof d.minSendIntervalMs === 'number') {
+        row(d.minSendIntervalMs > 0, 'send pause', Math.round(d.minSendIntervalMs / 1000) + 's between agent sends');
+    }
     return 'Doctor:' + NL + rows.join(NL);
 }
 export function renderPermissions(p) {
@@ -405,6 +415,74 @@ export function buildCompactCarryover(summary, task) {
     return out;
 }
 // ---------- /review ----------
+// ---------- Ctrl+C escalation ----------
+// Decide what a Ctrl+C does while the agent is busy. The FIRST press aborts
+// the currently running TOOL; a SECOND press within the window stops the WHOLE
+// run (including the queue). Outside the window it is a fresh first press.
+// Returns 'tool' | 'run'.
+export function ctrlCEscalation(sinceLastMs, windowMs = 2000) {
+    return sinceLastMs < windowMs ? 'run' : 'tool';
+}
+// True when the queued message is a slash-command. It must NOT be merged into
+// a task: the main loop has to execute it (e.g. /compact, /new).
+export function isSlashCommand(text) {
+    return String(text ?? '')
+        .trim()
+        .startsWith('/');
+}
+function queuedIsImage(a) {
+    return (String(a.mime || '').startsWith('image/') ||
+        isImageName(String(a.name || '')));
+}
+// Merge a batch of queued messages into a single task. Marker numbering is
+// PER-MESSAGE ([image#1]/[file#1] restart in every message), so a naive
+// concatenation would produce duplicate markers for different files. We
+// RENUMBER the markers across the batch and rebuild the attachments array in
+// the same order, keeping the text markers the source of truth.
+export function mergeMessages(msgs) {
+    const list = (msgs || []).filter((m) => String(m?.text ?? '').trim() !== '');
+    if (list.length === 0)
+        return { text: '', attachments: [] };
+    if (list.length === 1) {
+        return {
+            text: list[0].text,
+            attachments: (list[0].attachments || []).slice(),
+        };
+    }
+    let imgOffset = 0;
+    let fileOffset = 0;
+    const attachments = [];
+    const parts = [];
+    for (const m of list) {
+        const atts = m.attachments || [];
+        const images = atts.filter(queuedIsImage);
+        const files = atts.filter((a) => !queuedIsImage(a));
+        let text = String(m.text);
+        text = text.replace(/\[image#(\d+)\]/g, (whole, n) => {
+            const i = Number(n);
+            if (!Number.isFinite(i) || i < 1 || i > images.length)
+                return whole;
+            return '[image#' + (imgOffset + i) + ']';
+        });
+        text = text.replace(/\[file#(\d+)\]/g, (whole, n) => {
+            const i = Number(n);
+            if (!Number.isFinite(i) || i < 1 || i > files.length)
+                return whole;
+            return '[file#' + (fileOffset + i) + ']';
+        });
+        imgOffset += images.length;
+        fileOffset += files.length;
+        attachments.push(...atts);
+        parts.push(text.trim());
+    }
+    const header = 'The operator sent ' +
+        list.length +
+        ' messages while you were working. They are listed below in order — ' +
+        'treat them as one instruction.';
+    const text = header + NL + NL + parts.join(NL + NL + '---' + NL + NL);
+    return { text, attachments };
+}
+// ---------- /review ----------
 export function buildReviewPrompt(focus, hasStaged = false) {
     const scope = hasStaged ? 'staged' : 'uncommitted';
     const f = String(focus ?? '').trim();

package/dist/compact.js

@@ -0,0 +1,178 @@
+import { translate } from './i18n.js';
+import { buildCompactPrompt, buildCompactCarryover, isUsableCompactSummary, trimRestoredMessages, formatRestoredHistory, } from './commands.js';
+const NL = String.fromCharCode(10);
+/** How many times the summary call is retried before the local fallback. */
+export const COMPACT_SUMMARY_ATTEMPTS = 3;
+/** How many restored messages the local fallback keeps. */
+export const COMPACT_FALLBACK_LIMIT = 40;
+/**
+ * Compact the CURRENT chat: summarize it (retrying a few times, with a LOCAL
+ * history fallback), open a NEW chat, resend the system prompt and post the
+ * summary as the carried-over context. Shared by the manual `/compact` command
+ * and the automatic between-tools trigger, so both paths stay identical.
+ *
+ * The caller owns the browser and the throttle; this function only sends.
+ */
+export async function performCompact(opts) {
+    const { browser, workdir, locale, task, transcript = null, ui = null, buildSystemPrompt, tools, answerTimeoutMs, fallbackLimit = COMPACT_FALLBACK_LIMIT, skipUiLock = false, quiet = false, } = opts;
+    const t = translate(locale);
+    const log = (msg) => {
+        if (!quiet)
+            console.error(msg);
+    };
+    let currentChatId = opts.currentChatId;
+    if (!currentChatId) {
+        currentChatId = await browser.getCurrentChatId();
+    }
+    if (!currentChatId) {
+        log(t('compact.no_chat'));
+        return {
+            ok: false,
+            chatId: null,
+            summaryChars: 0,
+            beforeTokens: null,
+            error: t('compact.no_chat'),
+        };
+    }
+    const beforeTokens = browser.getLastTokenUsage
+        ? browser.getLastTokenUsage()
+        : null;
+    if (ui && !skipUiLock)
+        ui.lock(t('msg.input_locked'));
+    try {
+        if (!quiet)
+            log(t('compact.start'));
+        // 1) Ask the OLD chat to summarize itself.
+        let summary = '';
+        let summaryErr = '';
+        for (let attempt = 1; attempt <= COMPACT_SUMMARY_ATTEMPTS; attempt++) {
+            let prompt = buildCompactPrompt(locale);
+            if (attempt > 1) {
+                prompt +=
+                    locale === 'en'
+                        ? '\n\nIMPORTANT: reply with the summary as PLAIN TEXT only. Do NOT call any tools and do NOT output tool-call JSON/DSML.'
+                        : '\n\nВАЖНО: ответь ТОЛЬКО текстом резюме. НЕ вызывай инструменты и НЕ выводи JSON/DSML вызова инструмента.';
+            }
+            let answer = '';
+            try {
+                answer = await browser.ask(prompt, {
+                    agent: true,
+                    timeout: Math.max(60_000, answerTimeoutMs),
+                });
+            }
+            catch (e) {
+                summaryErr = e.message;
+            }
+            const trimmed = String(answer || '').trim();
+            if (/^\(прервано пользователем\)$/.test(trimmed)) {
+                return {
+                    ok: false,
+                    chatId: currentChatId,
+                    summaryChars: 0,
+                    beforeTokens,
+                    error: trimmed,
+                };
+            }
+            if (!summaryErr && isUsableCompactSummary(trimmed)) {
+                summary = trimmed;
+                summaryErr = '';
+                break;
+            }
+            if (!summaryErr)
+                summaryErr = trimmed || t('common.unknown');
+            if (attempt < COMPACT_SUMMARY_ATTEMPTS) {
+                log(t('compact.summary_retry', {
+                    v: summaryErr,
+                    attempt: String(attempt),
+                    max: String(COMPACT_SUMMARY_ATTEMPTS),
+                }));
+                await new Promise((r) => setTimeout(r, 3000 * attempt));
+            }
+        }
+        if (!summary) {
+            let fallback = '';
+            try {
+                const all = browser.fetchChatMessages && currentChatId
+                    ? await browser.fetchChatMessages(currentChatId).catch(() => [])
+                    : [];
+                const msgs = trimRestoredMessages(all, 0);
+                if (msgs.length) {
+                    fallback = formatRestoredHistory(msgs, { limit: fallbackLimit });
+                }
+            }
+            catch { }
+            fallback = String(fallback || '').trim();
+            if (fallback) {
+                summary = fallback;
+                log(t('compact.summary_fallback', { v: String(fallbackLimit) }));
+            }
+            else {
+                const err = summaryErr || t('common.unknown');
+                log(t('compact.summary_failed', { v: err }));
+                return {
+                    ok: false,
+                    chatId: currentChatId,
+                    summaryChars: 0,
+                    beforeTokens,
+                    error: err,
+                };
+            }
+        }
+        transcript?.log('compact_summary', {
+            chars: summary.length,
+            beforeTokens,
+        });
+        // 2) New chat + system prompt + the summary as the first message.
+        await browser.newChat();
+        await browser.ask(buildSystemPrompt({ workdir, tools, locale }), {
+            timeout: 60_000,
+            agent: false,
+        });
+        await browser.ask(buildCompactCarryover(summary, task), {
+            timeout: 60_000,
+            agent: false,
+        });
+        const newChatId = browser.getCurrentChatId
+            ? await browser.getCurrentChatId()
+            : null;
+        if (!quiet) {
+            log(t('compact.done') +
+                NL +
+                t('compact.report', {
+                    chars: summary.length,
+                    tokens: beforeTokens === null
+                        ? t('common.unknown')
+                        : String(beforeTokens),
+                }));
+        }
+        if (ui && !quiet) {
+            ui.printAbove(NL +
+                '--- compacted context ---' +
+                NL +
+                summary +
+                NL +
+                '--- end ---' +
+                NL);
+        }
+        return {
+            ok: true,
+            chatId: newChatId,
+            summaryChars: summary.length,
+            beforeTokens,
+        };
+    }
+    catch (e) {
+        log(e.message);
+        return {
+            ok: false,
+            chatId: currentChatId,
+            summaryChars: 0,
+            beforeTokens,
+            error: e.message,
+        };
+    }
+    finally {
+        if (ui && !skipUiLock)
+            ui.unlock();
+    }
+}

package/dist/config-menu.js

@@ -105,11 +105,26 @@ export function runConfigMenu(opts) {
         output.write(lines.join('\n') + '\n');
         lastRows = lines.reduce((n, l) => n + rowsOf(l), 0);
     };
-    const cleanup = () => {
+    // Erase the rendered menu block from the screen. Used on exit so the config
+    // list does not stay in the terminal history / scrollback (the operator
+    // asked for the menu to disappear after Esc).
+    const clearBlock = () => {
+        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');
+            lastRows = 0;
+        }
+    };
+    const cleanup = (clearOnExit = false) => {
         if (exited)
             return;
         exited = true;
         input.removeListener('data', onData);
+        if (clearOnExit)
+            clearBlock();
         if (input.setRawMode)
             input.setRawMode(wasRaw || false);
         output.write(ESC + '[?25h'); // restore the cursor
@@ -167,13 +182,14 @@ export function runConfigMenu(opts) {
                     break;
                 }
                 if (ch === ESC) {
+                    // Cancel the edit (do NOT exit the menu) — Esc in the field is
+                    // "abandon this value", not "close the config".
                     editing = false;
                     editBuf = '';
                     break;
                 }
                 if (ch === '\x03') {
-                    cleanup();
-                    output.write('\n');
+                    cleanup(true);
                     return;
                 }
                 if (ch === '\x7f' || ch === '\b') {
@@ -205,8 +221,9 @@ export function runConfigMenu(opts) {
             }
             const ch = s[i];
             if (ch === 'q' || ch === 'Q' || ch === '\x03' || ch === ESC) {
-                cleanup();
-                output.write('\n');
+                // Erase the menu block from the screen so the config list does not
+                // linger in the terminal history after Esc.
+                cleanup(true);
                 return;
             }
             if (ch === 'k') {

package/dist/config.js

@@ -48,6 +48,10 @@ export const DEFAULTS = {
         incompleteWaitMs: 2000,
         autoContinue: true,
         continueMinGapMs: 1500,
+        askDeadlineMs: 240000,
+        maxAfterToolRetries: 6,
+        autoCompact: false,
+        autoCompactPct: 95,
         resendPromptOnResume: false,
         deepThinking: false,
         webSearch: true,
@@ -59,6 +63,7 @@ export const DEFAULTS = {
     },
     ui: {
         locale: DEFAULT_LOCALE,
+        contextLimit: 1_000_000,
     },
 };
 export function loadConfig() {
@@ -274,6 +279,36 @@ export const CONFIG_SCHEMA = [
         labelKey: 'cfg.f.browser_continueMinGapMs',
         groupKey: 'cfg.group.browser',
     },
+    {
+        path: 'browser.askDeadlineMs',
+        type: 'number',
+        min: 30000,
+        max: 1800000,
+        labelKey: 'cfg.f.browser_askDeadlineMs',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.maxAfterToolRetries',
+        type: 'number',
+        min: 0,
+        max: 50,
+        labelKey: 'cfg.f.browser_maxAfterToolRetries',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.autoCompact',
+        type: 'boolean',
+        labelKey: 'cfg.f.browser_autoCompact',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.autoCompactPct',
+        type: 'number',
+        min: 50,
+        max: 100,
+        labelKey: 'cfg.f.browser_autoCompactPct',
+        groupKey: 'cfg.group.browser',
+    },
     {
         path: 'browser.resendPromptOnResume',
         type: 'boolean',
@@ -292,6 +327,14 @@ export const CONFIG_SCHEMA = [
         labelKey: 'cfg.f.browser_webSearch',
         groupKey: 'cfg.group.browser',
     },
+    {
+        path: 'ui.contextLimit',
+        type: 'number',
+        min: 10_000,
+        max: 10_000_000,
+        labelKey: 'cfg.f.ui_contextLimit',
+        groupKey: 'cfg.group.ui',
+    },
 ];
 export function getConfigField(path) {
     return CONFIG_SCHEMA.find((f) => f.path === path);

package/dist/confirm.js

@@ -1,18 +1,30 @@
 import * as readlinePromises from 'readline/promises';
 import { theme } from './theme.js';
 import { unifiedDiff, colorDiff } from './diff.js';
+import { translate, DEFAULT_LOCALE } from './i18n.js';
 export class ConfirmManager {
     settings;
     alwaysConfirm;
     allowedForSession;
-    constructor({ config } = {}) {
+    locale;
+    constructor({ config, locale = DEFAULT_LOCALE, } = {}) {
         const c = config || {};
+        this.locale = locale;
         this.settings = {
             write: c.write !== false,
             edit: c.edit !== false,
             bash: c.bash !== false,
         };
-        this.alwaysConfirm = (c.alwaysConfirm || []).map((p) => new RegExp(p, 'i'));
+        // An invalid operator-supplied regex must NEVER crash the run. Fall back to
+        // a literal substring match (case-insensitive) for that pattern.
+        this.alwaysConfirm = (c.alwaysConfirm || []).map((p) => {
+            try {
+                return new RegExp(p, 'i');
+            }
+            catch {
+                return new RegExp(escapeRegExp(p), 'i');
+            }
+        });
         this.allowedForSession = new Set();
     }
     _matchesAlwaysConfirm(command) {
@@ -28,21 +40,27 @@ export class ConfirmManager {
             return false;
         return true;
     }
+    // Hot-update the language (from /config lang). The manager holds the locale
+    // so its prompt follows the interface language without a restart.
+    setLocale(locale) {
+        this.locale = locale;
+    }
     async ask({ kind, target, preview = null, message, }) {
         if (!this.shouldAsk(kind, target ?? null))
             return true;
         if (preview) {
             console.log(preview);
         }
-        const label = message || `Разрешить ${kind}?`;
+        const t = translate(this.locale);
+        const label = message || t('confirm.ask_label') + ' ' + kind + '?';
         const question = theme.warn(`${label} `) +
             theme.system('[') +
             theme.assistant('y') +
-            theme.system(' = да, ') +
+            theme.system(' = ' + t('common.yes') + ', ') +
             theme.error('n') +
-            theme.system(' = нет, ') +
+            theme.system(' = ' + t('common.no') + ', ') +
             theme.user('a') +
-            theme.system(' = всегда для этого типа] ');
+            theme.system(' = ' + t('confirm.hint') + '] ');
         const answer = await this._prompt(question);
         if (answer === 'a') {
             if (kind !== 'bash' || !this._matchesAlwaysConfirm(target ?? '')) {
@@ -75,6 +93,12 @@ export class ConfirmManager {
         }
     }
 }
+// Escape a string so it can be used as a literal regex (used when an
+// operator-supplied alwaysConfirm pattern is invalid and we fall back to a
+// substring match).
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, (m) => '\\' + m);
+}
 export function formatDiffPreview(oldText, newText, { label } = {}) {
     const diff = unifiedDiff(oldText, newText, { label });
     return colorDiff(diff);

package/dist/context.js

@@ -25,9 +25,10 @@ async function readIfFile(p, budget) {
         if (!st.isFile())
             return null;
         const raw = await fs.readFile(p, 'utf-8');
+        // An EXISTING but empty file is still present: keep it so the prompt
+        // shows an (empty) AGENTS.md/MEMORY.md section instead of silently
+        // dropping the file. Only a read failure returns null.
         const content = clipIf(path.basename(p), raw, budget);
-        if (!content)
-            return null;
         return { path: p, content };
     }
     catch {

package/dist/gitTools.js

@@ -177,8 +177,9 @@ export function createGitTools(workdir) {
                 }
                 // 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() !== '(command produced no output)';
+                const stagedTrimmed = staged.trim();
+                const hasStaged = stagedTrimmed !== '' &&
+                    stagedTrimmed !== '(command produced no output)';
                 const addResult = hasStaged
                     ? '(index is not empty — add -A skipped)'
                     : await runGit('git add -A', workdir, 20_000);