zames_pro 2.73.11 → 2.74.0

package/dist/tui/TuiApp.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The Ink APP ROOT — composes the permanent log, the live status bar and the
+// input line into one flex column, and SUBSCRIBES to the TuiStore itself via
+// `useSyncExternalStore`.
+//
+// Subscribing inside the tree (not by passing `state` as a prop) means the
+// adapter calls `render()` exactly once and every store mutation re-renders
+// only the components that read the changed slice. The top section is <Static>
+// (never repainted), the bottom section re-renders as state changes, so the
+// input stays pinned at the bottom while answers scroll up into scrollback.
+import React, { useSyncExternalStore } from 'react';
+import { Box } from 'ink';
+import { LogView } from './LogView.js';
+import { StatusBar } from './StatusBar.js';
+import { InputLine } from './InputLine.js';
+import { suggestRowCount } from '../input/suggest.js';
+export function TuiApp({ store, inputProps, initialPrintedCount = 0, }) {
+    const state = useSyncExternalStore(store.subscribe, store.getSnapshot);
+    // The watermark is fixed for the lifetime of this mount.
+    const [watermark] = React.useState(initialPrintedCount);
+    const entries = watermark > 0 ? state.log.slice(watermark) : state.log;
+    // Cursor rows above the input box in the INLINE live area: divider + status
+    // + the suggestion popup (which renders above the box and would otherwise
+    // shift the caret down by its row count). Without the suggestRows term the
+    // caret drifted whenever the «/» list opened.
+    const suggestRows = suggestRowCount(state.edit.buf, state.commands);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(LogView, { entries: entries }), _jsx(StatusBar, { state: state }), _jsx(InputLine, { ...inputProps, store: store, prompt: state.prompt, locale: state.locale, commands: state.commands, locked: state.locked, cursorTop: 3 + suggestRows })] }));
+}

package/dist/tui/TuiEditor.js

@@ -0,0 +1,490 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { TuiStore } from './store.js';
+import { TuiApp } from './TuiApp.js';
+import { FullScreenApp } from './FullScreenApp.js';
+import { AttachmentStore } from '../attachments.js';
+import { translate } from '../i18n.js';
+import { expandPastes, formatTokenStatus, tokenStatusLevel, wrapToWidth, truncateToWidth, } from '../input/layout.js';
+import { contentWidth } from '../width.js';
+import { theme } from '../theme.js';
+import { renderMarkdown } from '../markdown.js';
+import { summarizeToolCall, looksLikeToolError } from '../tool-summary.js';
+import { extractCodeBlocks } from '../code-blocks.js';
+import { randomThinkingPhrase, stripEllipsis } from '../spinner.js';
+export class TuiEditor {
+    store = new TuiStore();
+    attachments = new AttachmentStore();
+    // ---- imperative surface used by index.ts / run-task.ts ----
+    onSubmit = null;
+    onEscape = null;
+    onCtrlC = null;
+    onHistoryChange = null;
+    onAttach = null;
+    onClipboard = null;
+    onQueueQuery = null;
+    onTasksQuery = null;
+    onContextQuery = null;
+    onToggleQuery = null;
+    /** Copy text to the OS clipboard. Wired to writeClipboardText in index.ts;
+     *  returns { ok, via } so the editor can report the outcome. */
+    onCopyText = null;
+    busy = false;
+    locked = false;
+    history = [];
+    contextLimit = 1_000_000;
+    /** Marker that the editor is started (kept for API compatibility). */
+    rendered = false;
+    /** Marks this editor as the Ink TUI (used to pick the Ink confirm modal). */
+    isTui = true;
+    instance = null;
+    prompt;
+    commands;
+    locale;
+    contextTokens = null;
+    statusText = '';
+    pendingText = null;
+    tmpDir = '';
+    badgeTimer = null;
+    alternateScreen;
+    /**
+     * How many log entries have already been painted to the terminal. Used as
+     * the <Static> watermark across a pause/resume remount, so the scrollback is
+     * not reprinted. Reset by clearScreen (the screen is wiped).
+     */
+    printedCount = 0;
+    /** SIGWINCH handler installed while the app is mounted. */
+    onResize = null;
+    resizeTimer = null;
+    constructor(opts = {}) {
+        this.prompt = opts.prompt ?? '> ';
+        this.commands = opts.commands ?? [];
+        this.locale = opts.locale ?? 'ru';
+        this.alternateScreen = !!opts.alternateScreen;
+        this.store.set({
+            prompt: this.prompt,
+            commands: this.commands,
+            locale: this.locale,
+            history: this.history,
+        });
+    }
+    // ---------- lifecycle ----------
+    start() {
+        if (!(process.stdin.isTTY && process.stdout.isTTY))
+            return false;
+        if (this.instance)
+            return true;
+        this.mount();
+        return true;
+    }
+    buildInputProps() {
+        return {
+            onSubmit: (text, atts) => this.handleSubmit(text, atts),
+            onEscape: () => this.onEscape?.(),
+            onCtrlC: () => this.onCtrlC?.(),
+            onCopyCode: () => this.copyCode(),
+            onAttach: (raw) => this.onAttach?.(raw) ?? null,
+            onClipboard: () => this.onClipboard?.() ?? Promise.resolve(null),
+            onHistoryChange: (h) => {
+                this.history = h;
+                this.onHistoryChange?.(h);
+            },
+            onClearScreen: () => this.clearScreen(),
+            attachments: this.attachments.items,
+            onPastesChange: (pastes) => this.store.set({ pastes }),
+        };
+    }
+    mount() {
+        // Seed the editor history from the persisted list IF the store has none
+        // yet (first mount). index.ts sets `this.history` from loadHistory()
+        // BEFORE start(); the store owns the live buffer so a later remount keeps
+        // both the typed line and the history.
+        const snap = this.store.getSnapshot();
+        if (snap.edit.history.length === 0 && this.history.length > 0) {
+            this.store.set({
+                edit: {
+                    ...snap.edit,
+                    history: this.history.slice(),
+                    histIndex: this.history.length,
+                },
+            });
+        }
+        // growing down from the current cursor row; a fresh terminal starts at the
+        // top, so without this the panel would sit in the middle of an empty
+        // screen. Filling the viewport with newlines first makes Ink's output land
+        // at the bottom, and every later log row scrolls the screen up while the
+        // panel stays put — the same technique the legacy LineEditor used
+        // (`_padToBottom`).
+        this.padToBottom();
+        const tree = this.alternateScreen ? (_jsx(FullScreenApp, { store: this.store, inputProps: this.buildInputProps() })) : (_jsx(TuiApp, { store: this.store, inputProps: this.buildInputProps(), initialPrintedCount: this.printedCount }));
+        this.instance = render(tree, {
+            exitOnCtrlC: false,
+            // The app manages console.log/error itself (index.ts routes them to
+            // printAbove), so Ink must not patch them: an unmount (clearScreen)
+            // would otherwise restore the native console and lose that routing.
+            patchConsole: false,
+            alternateScreen: this.alternateScreen,
+        });
+        this.rendered = true;
+        this.installResizeHandler();
+        // Entries shown so far are now on screen; a later remount must not reprint
+        // them.
+        this.printedCount = this.store.getSnapshot().log.length;
+        // Badges (queue/tasks/toggles/context) are pulled on a light timer so they
+        // stay live without the caller polling — mirroring the old editor, whose
+        // status render read them on every repaint.
+        if (!this.badgeTimer) {
+            this.badgeTimer = setInterval(() => this.refreshBadges(), 1000);
+            if (this.badgeTimer.unref)
+                this.badgeTimer.unref();
+        }
+    }
+    dispose() {
+        if (this.instance) {
+            this.instance.unmount();
+            this.instance = null;
+        }
+        if (this.badgeTimer) {
+            clearInterval(this.badgeTimer);
+            this.badgeTimer = null;
+        }
+        this.removeResizeHandler();
+        this.rendered = false;
+    }
+    /**
+     * Repaint on terminal resize. Ink's OWN resize handling only clears on a
+     * WIDTH DECREASE; on other resizes the terminal reflowed the printed rows
+     * while Ink's relative erase still points at the old frame, so the live
+     * panel DUPLICATED at several indents (the artifact the operator reported).
+     * We fix it by rebuilding the Ink instance on resize — that resets the
+     * internal frame buffer. This is now SAFE because the editor buffer lives in
+     * the STORE (a remount no longer wipes the typed line) and we keep the log
+     * watermark, so the scrollback is neither lost nor reprinted.
+     */
+    installResizeHandler() {
+        if (this.onResize)
+            return;
+        this.onResize = () => {
+            if (this.resizeTimer)
+                clearTimeout(this.resizeTimer);
+            this.resizeTimer = setTimeout(() => {
+                this.resizeTimer = null;
+                if (!this.instance)
+                    return;
+                // Preserve the log: the watermark stays at the current length, so the
+                // new instance prints NOTHING already on screen (no history loss, no
+                // duplicate).
+                this.printedCount = this.store.getSnapshot().log.length;
+                this.instance.unmount();
+                this.instance = null;
+                this.mount();
+            }, 100);
+            if (this.resizeTimer.unref)
+                this.resizeTimer.unref();
+        };
+        process.stdout.on('resize', this.onResize);
+    }
+    removeResizeHandler() {
+        if (this.onResize) {
+            process.stdout.removeListener('resize', this.onResize);
+            this.onResize = null;
+        }
+        if (this.resizeTimer) {
+            clearTimeout(this.resizeTimer);
+            this.resizeTimer = null;
+        }
+    }
+    /** Emit newlines so Ink's output starts at the BOTTOM of the viewport. */
+    padToBottom() {
+        const rows = process.stdout.rows || 24;
+        if (rows > 1)
+            process.stdout.write('\n'.repeat(rows - 1));
+    }
+    /** Suspend the tree for a foreign full-screen UI (e.g. the /config menu). */
+    pause() {
+        if (this.instance) {
+            this.instance.unmount();
+            this.instance = null;
+        }
+    }
+    /** Resume after pause(): remount the tree fresh. */
+    resume() {
+        if (!this.instance && process.stdin.isTTY && process.stdout.isTTY) {
+            this.mount();
+        }
+    }
+    // ---------- submission ----------
+    handleSubmit(display, atts) {
+        const text = expandPastes(this.store.getSnapshot().pastes, display);
+        this.attachments.reset();
+        // A turn separator + a BAR-marked, clearly-colored operator message, so an
+        // operator turn never blends with the model's answer (operator request).
+        this.printAbove(theme.turnRule('─'.repeat(contentWidth())));
+        this.printAbove(theme.userBar('▌ ') +
+            theme.user(wrapToWidth(display, contentWidth() - 2)));
+        this.store.set({ pastes: [] });
+        this.onSubmit?.(text, atts);
+        if (this.busy)
+            this.thinking();
+    }
+    // ---------- status / log API ----------
+    /** Print a block into the permanent log above the input. */
+    printAbove(text) {
+        const s = String(text);
+        const lines = s.split('\n');
+        // `raw: true` — the caller already applied its own theme colors; LogView
+        // must print the line verbatim instead of re-wrapping it (double ANSI
+        // nesting made a tool line look dim/wrong).
+        this.store.pushLogs(lines.map((line) => ({
+            kind: 'system',
+            text: line,
+            raw: true,
+        })));
+    }
+    setStatus(text) {
+        this.statusText = text || '';
+        this.store.set({ statusText: this.statusText });
+    }
+    setSendState(state) {
+        const next = state === 'generating' || state === 'paused' || state === 'settled'
+            ? state
+            : '';
+        this.store.set({ sendState: next });
+    }
+    setPrompt(str) {
+        this.prompt = str;
+        this.store.set({ prompt: str });
+    }
+    setProvider(text) {
+        this.store.set({ provider: String(text || '').trim() });
+    }
+    /** Header info for full-screen mode (title/version/workdir). */
+    setHeader(info) {
+        this.store.set({
+            ...(info.title !== undefined ? { title: info.title } : {}),
+            ...(info.version !== undefined ? { version: info.version } : {}),
+            ...(info.workdir !== undefined ? { workdir: info.workdir } : {}),
+            ...(info.mouseScroll !== undefined
+                ? { mouseScroll: info.mouseScroll }
+                : {}),
+        });
+    }
+    setStatusLine(text) {
+        this.store.set({ statusLine: String(text || '').trim() });
+    }
+    setContextStatus(tokens) {
+        this.contextTokens =
+            typeof tokens === 'number' && Number.isFinite(tokens) ? tokens : null;
+        this.applyContext();
+    }
+    setContextLimit(limit) {
+        if (typeof limit === 'number' && Number.isFinite(limit) && limit > 0) {
+            this.contextLimit = limit;
+        }
+        this.applyContext();
+    }
+    applyContext() {
+        const n = this.onContextQuery ? this.readContext() : this.contextTokens;
+        const text = formatTokenStatus(n, this.contextLimit) || null;
+        const level = tokenStatusLevel(n, this.contextLimit);
+        this.store.set({ contextText: text, contextLevel: level });
+    }
+    readContext() {
+        try {
+            const n = this.onContextQuery?.();
+            return typeof n === 'number' ? n : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    setLocale(locale) {
+        this.locale = locale;
+        this.store.set({ locale });
+    }
+    setCommands(commands) {
+        this.commands = commands;
+        this.store.set({ commands });
+    }
+    setTmpDir(dir) {
+        this.tmpDir = dir;
+    }
+    clear() {
+        // The buffer lives in the input component's state; this API hook is kept
+        // for compatibility but there is nothing to reset here.
+    }
+    refreshStatus() {
+        this.refreshBadges();
+    }
+    /** Pull the live badge values (queue/tasks/toggles/context) into the store. */
+    refreshBadges() {
+        if (this.onQueueQuery) {
+            try {
+                this.store.set({ queueLength: this.onQueueQuery() || 0 });
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        if (this.onTasksQuery) {
+            try {
+                this.store.set({ tasks: this.onTasksQuery() || '' });
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        if (this.onToggleQuery) {
+            try {
+                const s = this.onToggleQuery();
+                if (s) {
+                    this.store.set({
+                        thinkingEnabled: !!s.deepThinking,
+                        searchEnabled: !!s.webSearch,
+                    });
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        this.applyContext();
+    }
+    clearScreen() {
+        // Drop the permanent log and let Ink repaint a clean screen. A REMOUNT is
+        // required because <Static> never un-renders items it has already printed:
+        // clearing the store alone would leave the old rows on screen. The
+        // watermark goes back to 0 so the (now empty) log is the fresh baseline.
+        this.store.set({ log: [] });
+        this.printedCount = 0;
+        if (this.instance) {
+            this.instance.unmount();
+            this.instance = null;
+            this.mount();
+        }
+    }
+    lock(status) {
+        this.locked = true;
+        if (status)
+            this.setStatus(theme.dim(status));
+        this.store.set({ locked: true });
+    }
+    unlock() {
+        this.locked = false;
+        if (this.statusText)
+            this.setStatus('');
+        this.store.set({ locked: false });
+    }
+    // ---------- spinner-compatible interface ----------
+    thinking() {
+        if (this.pendingText) {
+            this.setStatus('✎ ' + this.pendingText);
+            return;
+        }
+        this.startAnimated(randomThinkingPhrase(this.locale));
+    }
+    startAnimated(baseText) {
+        this.store.set({
+            animBase: stripEllipsis(baseText),
+            animStart: Date.now(),
+        });
+    }
+    sendPause(seconds) {
+        const label = translate(this.locale)('spinner.pause', { n: seconds });
+        if (this.store.getSnapshot().animBase) {
+            this.store.set({ animBase: stripEllipsis(label) });
+        }
+        else {
+            this.startAnimated(label);
+        }
+    }
+    setPending(text) {
+        this.pendingText = text && String(text).length ? String(text) : null;
+        this.store.set({ pendingText: this.pendingText });
+    }
+    stop() {
+        this.statusText = '';
+        this.pendingText = null;
+        this.store.set({ statusText: '', animBase: '', pendingText: null });
+    }
+    toolCall(name, args) {
+        const full = safeJson(args);
+        void full;
+        const summary = summarizeToolCall(name, (typeof args === 'object' && args !== null ? args : {}));
+        const detail = summary.detail
+            ? truncateToWidth(summary.detail, contentWidth() - name.length - 6)
+            : truncateToWidth(full, contentWidth());
+        this.printAbove(theme.tool('🔧 ' + name) + (detail ? theme.dim('(' + detail + ')') : ''));
+        this.store.set({ animBase: '', sendState: '' });
+        this.startAnimated(translate(this.locale)('spinner.running_tool', { name }));
+        this.refreshBadges();
+    }
+    toolResult(result) {
+        this.stop();
+        const text = typeof result === 'string' ? result : safeJson(result);
+        const preview = truncateToWidth(text.split('\n').join(' ↵ '), contentWidth());
+        // A simple outcome icon: a tool result that is clearly an error gets ✖, a
+        // normal one ✔. The result already flows here (a mutating tool's failure
+        // is reported as an Error string by the loop), so this is cheap and makes
+        // a failed call visible at a glance.
+        const icon = looksLikeToolError(text) ? '   ✖ ' : '   ✔ ';
+        this.printAbove(theme.toolResult(icon + preview));
+    }
+    assistant(msg) {
+        this.stop();
+        const rendered = renderMarkdown(msg);
+        this.printAbove('\n' + theme.assistant(translate(this.locale)('editor.answer')));
+        this.printAbove(rendered);
+        this.printAbove('\n');
+        // Remember the answer's code blocks so the operator can copy one by hotkey
+        // (a terminal has no copy buttons). Extraction is on the RAW markdown —
+        // the rendered text is full of ANSI and must never be copied.
+        const blocks = extractCodeBlocks(msg);
+        this.store.set({ codeBlocks: blocks, codeFocus: -1 });
+        if (blocks.length)
+            this.refreshBadges();
+    }
+    /** Copy the focused code block (or the LAST when none is focused). */
+    copyCode(index) {
+        const snap = this.store.getSnapshot();
+        const blocks = snap.codeBlocks;
+        if (!blocks.length) {
+            this.printAbove(theme.dim(translate(this.locale)('copy.no_code')));
+            return false;
+        }
+        const pick = typeof index === 'number'
+            ? blocks.find((b) => b.index === index) ?? null
+            : snap.codeFocus >= 0
+                ? blocks[snap.codeFocus] ?? null
+                : blocks[blocks.length - 1];
+        if (!pick) {
+            this.printAbove(theme.warn(translate(this.locale)('copy.bad_index', { n: String(index) })));
+            return false;
+        }
+        const res = this.onCopyText?.(pick.text) ?? { ok: false, via: 'none' };
+        const label = 'code #' + pick.index + (pick.lang ? ' (' + pick.lang + ')' : '');
+        if (res.ok) {
+            this.printAbove(theme.assistant(translate(this.locale)('copy.done', { tool: res.via }) + ' — ' + label));
+        }
+        else {
+            this.printAbove(theme.warn(translate(this.locale)('copy.failed', { tool: res.via }) + ' — ' + label));
+        }
+        return res.ok;
+    }
+    warning(msg) {
+        const wrapped = wrapToWidth('⚠ ' + msg, contentWidth());
+        this.printAbove('\n' + theme.warn(wrapped));
+    }
+    succeed() { }
+    fail() { }
+}
+function safeJson(v) {
+    if (typeof v === 'string')
+        return v;
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}