zames_pro 2.89.0 → 2.90.0

package/dist/swallow.js

@@ -0,0 +1,45 @@
+// N7: ACCOUNTING for swallowed exceptions instead of silent `catch {}`.
+//
+// The browser classes have ~180 empty catches (a selector probe, a best-effort
+// cleanup, an optional DOM read). When a site redesign breaks a selector, such
+// a catch turns the failure into silence: the UI health probe is clean, yet the
+// answer never appears. This helper records the failure by TAG (always) and
+// prints it only in debug mode, so the counters can be surfaced by /doctor and
+// the send telemetry without flooding the terminal.
+//
+// A genuinely expected empty catch (best-effort cleanup, an absent optional
+// element) keeps `swallowSilently()` with a WHY comment — the point is that
+// silence becomes an EXPLICIT choice, not the default.
+const counts = new Map();
+/** Record a swallowed failure. `detail` is only used in debug mode. */
+export function noteSwallowed(tag, err, debug = false) {
+    counts.set(tag, (counts.get(tag) ?? 0) + 1);
+    if (debug) {
+        const msg = err instanceof Error ? err.message : String(err ?? '');
+        console.error('[swallowed] ' + tag + (msg ? ': ' + msg : ''));
+    }
+}
+/**
+ * Run `fn`, swallowing (and counting) any error under `tag`.
+ * Returns `fallback` when it failed, so the caller keeps its happy path.
+ */
+export async function swallow(tag, fn, fallback, debug = false) {
+    try {
+        return await fn();
+    }
+    catch (e) {
+        noteSwallowed(tag, e, debug);
+        return fallback;
+    }
+}
+/** The swallowed-failure counters, sorted by count (for /doctor). */
+export function swallowedReport(limit = 5) {
+    return [...counts.entries()]
+        .map(([tag, count]) => ({ tag, count }))
+        .sort((a, b) => b.count - a.count || a.tag.localeCompare(b.tag))
+        .slice(0, limit);
+}
+/** Reset the counters (tests and a fresh session). */
+export function resetSwallowed() {
+    counts.clear();
+}

package/dist/system-prompt.js

@@ -1,5 +1,5 @@
 import path from 'path';
-import { translate } from './i18n.js';
+import { translate, DEFAULT_LOCALE } from './i18n.js';
 // The dev-mode BACKLOG instruction. English (agent-facing) like the rest of the
 // prompt. Deliberately narrow: one short note at most, and only when the idea
 // is OUTSIDE the current task — otherwise the model documents trivia instead
@@ -204,7 +204,7 @@ function renderToolSection(tools) {
         .map((t2) => `### ${t2.name}\n${t2.description}\nParameters: ${JSON.stringify(t2.parameters)}`)
         .join('\n\n');
 }
-export function buildSystemPrompt({ workdir, tools, gitContext = null, locale = 'ru', attachments = [], context = null, selfImprovement = false, provider, }) {
+export function buildSystemPrompt({ workdir, tools, gitContext = null, locale = DEFAULT_LOCALE, attachments = [], context = null, selfImprovement = false, provider, }) {
     const t = translate(locale);
     const toolDescriptions = renderToolSection(tools);
     // Emit the subagent guidance ONLY when the Task tool is actually in the set

package/dist/tree-commands.js

@@ -0,0 +1,36 @@
+// N2 group (c): the git / undo / rewind commands — /diff, /diffstat, /undo,
+// /undo-list (/history), /rewind-list (/checkpoints), /rewind. All of them
+// drive live stores (git, the undo store, the checkpoint store) and the editor
+// lock, so the work is INJECTED; the registry owns the names, aliases and the
+// argument forwarding.
+/** True when the typed line carries the `--staged` flag (any position). */
+export function hasStagedFlag(line) {
+    return /(^|\s)--staged(\s|$)/.test(line);
+}
+export function createTreeCommands(deps) {
+    return [
+        {
+            name: 'diff',
+            handler: (ctx) => deps.diff(hasStagedFlag(ctx.input)),
+        },
+        {
+            name: 'diffstat',
+            handler: (ctx) => deps.diffstat(hasStagedFlag(ctx.input)),
+        },
+        { name: 'undo', handler: () => deps.undo() },
+        {
+            name: 'undo-list',
+            aliases: ['history'],
+            handler: () => deps.undoList(),
+        },
+        {
+            name: 'rewind-list',
+            aliases: ['checkpoints'],
+            handler: () => deps.rewindList(),
+        },
+        {
+            name: 'rewind',
+            handler: (ctx) => deps.rewind(ctx.rest.split(/\s+/)[0] || '1', ctx.input),
+        },
+    ];
+}

package/dist/tui/FullScreenApp.js

@@ -17,14 +17,17 @@ import { StatusBar } from './StatusBar.js';
 import { InputLine } from './InputLine.js';
 import { translate } from '../i18n.js';
 import { suggestRowCount } from '../input/suggest.js';
-import { truncateToWidth, visLen } from '../input/layout.js';
+import { truncateToWidth, visLen, screenGutter, screenInnerCols, } from '../input/layout.js';
 import { fullScreenLayout } from './layout.js';
 import { useMouseWheel } from './useMouseWheel.js';
 import { UI, inputBorderCols } from './ui-colors.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);
+    // The header lives INSIDE the gutter, so it must lay out to the pane width:
+    // filling the terminal width would wrap the title row and add a row the
+    // layout does not reserve.
+    const cols = screenInnerCols(useWindowSize().columns || 80);
     const right = [state.provider && '[' + state.provider + ']']
         .filter(Boolean)
         .join(' ');
@@ -57,7 +60,13 @@ export function FullScreenApp({ store, inputProps, }) {
     // caret row can never drift apart (the component used to compute them
     // separately and the caret landed below the input box when the panel filled
     // the terminal).
-    const cols = Math.max(1, useWindowSize().columns || 80);
+    // Gutter on both sides: the operator asked for breathing room instead of a
+    // UI pinned to the terminal edges (most visible on a wide screen, where the
+    // theme's background made the flush layout look broken). Everything below
+    // (header, log wrap, status, input box, hint) uses the SAME pane width.
+    const termCols = Math.max(1, useWindowSize().columns || 80);
+    const gutter = screenGutter(termCols);
+    const cols = screenInnerCols(termCols);
     const fsLayout = fullScreenLayout({
         termRows,
         cols,
@@ -112,7 +121,7 @@ export function FullScreenApp({ store, inputProps, }) {
         const next = cur + 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", flexGrow: 1, flexShrink: 1, minHeight: 1, overflow: "hidden", justifyContent: "flex-end", children: all.length === 0 ? (_jsx(Text, { color: UI.dim, children: translate(state.locale)('editor.empty_hint') })) : (_jsx(LogList, { entries: visible })) }), _jsx(StatusBar, { state: state, divider: false }), _jsx(InputLine, { ...inputProps, store: store, 
+    return (_jsxs(Box, { flexDirection: "column", height: termRows, paddingLeft: gutter, paddingRight: gutter, children: [_jsx(Header, { store: store }), _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 1, overflow: "hidden", justifyContent: "flex-end", children: all.length === 0 ? (_jsx(Text, { color: UI.dim, 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.
                 // The log pane is FLEXIBLE now, so the panel below it starts right
                 // after everything above: header + as many log rows as fit + the

package/dist/tui/InputLine.js

@@ -12,10 +12,12 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Box, Text, useInput, usePaste, useCursor, useWindowSize, useStdin, } from 'ink';
 import { translate } from '../i18n.js';
 import { expandPastes, inputInnerCols, layoutInput, SUGGEST_PAGE, } from '../input/layout.js';
+import { screenInnerCols, screenGutter } from '../input/layout.js';
 import { insertText, insertPaste, insertNewline, backspace, del, moveLeft, moveRight, moveHome, moveEnd, wordLeft, wordRight, deleteWordLeft, deleteWordRight, killToLineEnd, moveVisualRows, pushUndo, undoEdit, historyUp, historyDown, searchStart, searchNext, searchAccept, searchCancel, searchInput, searchBackspace, recordHistory, afterSubmit, rememberDraft, } from './edit.js';
 import { dispatchKey, parseCsiU } from './keys.js';
 import { useSyncExternalStore } from 'react';
 import { matchSlashCommands, suggestWindow, completeSlashCommand, } from '../input/suggest.js';
+import { suggestRowCount } from '../input/suggest.js';
 import { UI, inputBorderStyle } from './ui-colors.js';
 /** Render the visual rows of the buffer with the prompt on the first row. */
 function InputRows({ prompt, buf, cols, }) {
@@ -23,8 +25,10 @@ function InputRows({ prompt, buf, cols, }) {
     return (_jsx(Box, { flexDirection: "column", children: lay.rows.map((r, i) => (_jsxs(Text, { children: [_jsx(Text, { color: UI.accent, bold: true, children: r.prefix }), _jsx(Text, { color: UI.text, children: r.text })] }, i))) }));
 }
 export function InputLine(props) {
+    // Pane width (gutter excluded): the box must not be wider than the padded
+    // root, or it overflows the row and the caret math drifts.
     const { columns } = useWindowSize();
-    const cols = columns || 80;
+    const cols = screenInnerCols(columns || 80);
     const { setCursorPosition } = useCursor();
     const [suggestSelected, setSuggestSelected] = useState(-1);
     // The visible page of the suggestion list follows the SELECTION: with more
@@ -317,8 +321,21 @@ export function InputLine(props) {
     // code re-measured `rowText` up to `cursorCol` code points, which
     // DOUBLE-counted wide chars: a CJK buffer put the caret at the line end
     // instead of under the cursor.
-    2 + lay.cursorCol;
-    setCursorPosition({ x: cursorX, y: (props.cursorTop ?? 3) + cursorRow });
+    // 2 (box border + inner padding) + the ROOT gutter (paddingLeft of the
+    // full-screen/inline root) + the column inside the box. The gutter was
+    // forgotten: at 170 columns the root pads 2, so the caret sat exactly 2
+    // cells LEFT of the text the operator typed.
+    screenGutter(columns || 80) + 2 + lay.cursorCol;
+    // The suggestion popup is drawn ABOVE the box in THIS component, so it pushes
+    // the input rows DOWN by its own height. `cursorTop` (from the app) counts
+    // the rows above the INPUT BOX, not above the popup, so the popup rows are
+    // added HERE — exactly where they are rendered. (A caller that folded them
+    // in as well double-counted them and the caret landed inside the popup.)
+    const popupRows = suggestions.length > 0 ? suggestRowCount(st.buf, props.commands, cols) : 0;
+    setCursorPosition({
+        x: cursorX,
+        y: (props.cursorTop ?? 3) + popupRows + cursorRow,
+    });
     const { shown, moreCount } = suggestWindow(suggestions, suggestOffset);
     const t = translate(props.locale);
     return (_jsxs(Box, { flexDirection: "column", children: [suggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [shown.map((c, i) => {

package/dist/tui/LogView.js

@@ -1,6 +1,7 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Static, Box, Text } from 'ink';
 import { theme } from '../theme.js';
+import { UI } from './ui-colors.js';
 /** One log entry. `raw` items already carry ANSI colors and are printed
  *  verbatim; structured items get a themed prefix. */
 function LogRow({ entry }) {
@@ -10,10 +11,15 @@ function LogRow({ entry }) {
         return _jsx(Text, { children: entry.text });
     }
     if (entry.bar) {
-        // An operator turn: `▌` on EVERY visual row. Applying the bar to the whole
-        // (already wrapped) block keeps the indent equal on continuation lines —
-        // prefixing only the first line made a multi-line message look ragged.
-        return _jsx(Text, { children: theme.userBar('▌ ') + theme.user(entry.text) });
+        // An operator turn: `▌` on EVERY visual row.
+        //
+        // A SINGLE <Text> with a colored prefix child is NOT enough: Ink renders a
+        // multi-line string as-is, so the prefix appears on the FIRST line only
+        // (the old comment claimed the opposite and the bug survived for that
+        // reason). The text is already hard-wrapped by the caller
+        // (wrapToWidth), so split it back into rows and draw the bar on each one.
+        const rows = String(entry.text ?? '').split(String.fromCharCode(10));
+        return (_jsx(Box, { flexDirection: "column", children: rows.map((row, i) => (_jsxs(Text, { children: [_jsx(Text, { color: UI.userBar, children: "\u258C " }), _jsx(Text, { color: UI.user, children: row })] }, i))) }));
     }
     switch (entry.kind) {
         case 'user':

package/dist/tui/StatusBar.js

@@ -1,6 +1,7 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useAnimation, useWindowSize } from 'ink';
 import { translate } from '../i18n.js';
+import { screenInnerCols } from '../input/layout.js';
 import { DOTS, stripEllipsis } from '../spinner.js';
 import { UI } from './ui-colors.js';
 import { truncateToWidth, visLen } from '../input/layout.js';
@@ -175,7 +176,9 @@ export function StatusBar({ state, divider = true, }) {
     // row sat empty; measuring the badges (they are DROPPED whole when the row
     // is tight, the context counter survives longest) is both accurate and
     // keeps the layout stable.
-    const cols = useWindowSize().columns || 80;
+    // Pane width: the full-screen/inline root keeps a gutter on both sides, so
+    // the divider must not run to the terminal edge.
+    const cols = screenInnerCols(useWindowSize().columns || 80);
     const badgeW = badgeTextWidth(state);
     const gap = badgeW > 0 ? 2 : 0;
     const leftBudget = Math.max(0, cols - 2 - badgeW - gap);

package/dist/tui/TuiApp.js

@@ -14,6 +14,7 @@ import { LogView } from './LogView.js';
 import { StatusBar } from './StatusBar.js';
 import { InputLine } from './InputLine.js';
 import { suggestRowCount } from '../input/suggest.js';
+import { screenGutter, screenInnerCols } from '../input/layout.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.
@@ -23,7 +24,15 @@ export function TuiApp({ store, inputProps, initialPrintedCount = 0, }) {
     // + 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 cols = useWindowSize().columns || 80;
+    // The INLINE layout needs the same gutter the full-screen one has: the
+    // operator's complaint was that switching a theme made the flush edges
+    // obvious (the themed background only covers what we paint). The width fed
+    // to the suggest-row math must match the padded pane, or the caret drifts.
+    const gutter = screenGutter(useWindowSize().columns || 80);
+    const cols = screenInnerCols(useWindowSize().columns || 80);
     const suggestRows = suggestRowCount(state.edit.buf, state.commands, cols);
-    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 })] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: gutter, paddingRight: gutter, 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, 
+                // 3 = divider + status + the box TOP border. The popup sits ABOVE
+                // the box and does not move it, so it must not shift the caret.
+                cursorTop: 3 })] }));
 }

package/dist/tui/layout.js

@@ -12,13 +12,26 @@ const STATUS_ROWS = 1;
 export const HINT_ROWS = 1;
 export function fullScreenLayout(input) {
     const termRows = Math.max(1, Math.floor(input.termRows) || 24);
+    // `cols` is the WIDTH OF A PANE, not of the terminal: the full-screen app
+    // puts a gutter on both sides (screenInnerCols), and the input box wraps to
+    // exactly that inner width. Using the terminal width here reserved one row
+    // too few the moment a long input filled the pane (the box then wrapped an
+    // extra line and the caret drifted), so the caller MUST pass the inner
+    // width — and the pure helper stays consistent with what it renders.
     const cols = Math.max(1, Math.floor(input.cols) || 80);
     const box = inputBoxRows(input.prompt, input.buf, input.cursor, cols, input.borderCols ?? 2);
     const suggestRows = Math.max(0, Math.floor(input.suggestRows) || 0);
     const panelRows = HEADER_ROWS + STATUS_ROWS + box + suggestRows + HINT_ROWS;
     const logHeight = Math.max(1, termRows - panelRows);
     // The caret counts the SAME viewport the reservation uses.
-    const cursorTop = HEADER_ROWS + logHeight + suggestRows + STATUS_ROWS + 1;
+    // The suggestion popup is drawn ABOVE the box and the box does NOT move, so
+    // the caret row must NOT include `suggestRows`: adding it put the terminal
+    // caret on the popup line (the operator saw the block cursor between
+    // `/chats` and the box). The popup only SHRINKS the log viewport — which
+    // `logHeight` above already accounts for.
+    // `cursorTop` is the row of the input BOX top border (the popup and the
+    // buffer rows are added by InputLine, where they are actually rendered).
+    const cursorTop = HEADER_ROWS + logHeight + STATUS_ROWS + 1;
     return {
         headerRows: HEADER_ROWS,
         statusRows: STATUS_ROWS,

package/dist/tui/store.js

@@ -13,6 +13,7 @@
 // The store keeps the WHOLE app state in one immutable snapshot object so
 // `useSyncExternalStore` gets a stable reference between changes (a new object
 // is produced only on an actual mutation).
+import { DEFAULT_LOCALE } from '../i18n.js';
 import { initialEditState } from './edit.js';
 function initialState() {
     return {
@@ -34,7 +35,7 @@ function initialState() {
         history: [],
         prompt: '> ',
         commands: [],
-        locale: 'ru',
+        locale: DEFAULT_LOCALE,
         contextText: null,
         contextLevel: null,
         queueLength: 0,

package/dist/tui/ui-colors.js

@@ -23,6 +23,8 @@ export function uiColorsFrom(p) {
         err: p.error,
         system: p.system,
         title: p.taskSummary,
+        userBar: p.userBar,
+        user: p.user,
     };
 }
 export const UI = uiColorsFrom(ALL_PALETTES[DEFAULT_THEME]);

package/dist/width.js

@@ -4,11 +4,13 @@
 // is printed at the full terminal width while something else stops at 100 --
 // the mismatch looked ragged after a resize.
 //
-// 0 (default) = auto: the terminal width, capped at DEFAULT_CONTENT_WIDTH.
-// A longer line is harder to read and the eye loses the start of the next
-// line on a wide terminal, so there is a cap.
+// 0 (default) = the FULL terminal width (minus one autowrap-safety column).
+// The old default capped the content at 100 columns, which on a wide terminal
+// left a wide empty band on the right of every answer; the operator asked for
+// the text to use the whole width. A cap is still available per-run via
+// `ui.answerWidth` when a narrower column is easier to read.
 // > 0 = an explicit cap (still never wider than the terminal).
-const DEFAULT_CONTENT_WIDTH = 100;
+const DEFAULT_CONTENT_WIDTH = 0;
 let configured = 0;
 /** Set the configured content width (0 or a non-positive value = auto). */
 export function setContentWidth(width) {
@@ -21,5 +23,8 @@ export function setContentWidth(width) {
 export function contentWidth() {
     const cols = process.stdout.columns || 80;
     const cap = configured > 0 ? configured : DEFAULT_CONTENT_WIDTH;
-    return Math.max(20, Math.min(cap, cols - 1));
+    // A cap of 0 means "no cap beyond the terminal": use every column except
+    // the last one (autowrap safety).
+    const limit = cap > 0 ? Math.min(cap, cols - 1) : cols - 1;
+    return Math.max(20, limit);
 }