zames_pro 2.89.0 → 2.90.0

package/dist/info-commands.js

@@ -0,0 +1,61 @@
+// N2 group (a): the INFORMATIONAL slash commands — /status, /chat, /pwd,
+// /transcript, /cost, /limits, /memory, /skills. Their logic drives live
+// state, so everything is INJECTED (the same DI shape as config-command.ts):
+// the registry calls the handler, the handler asks the deps for data and
+// prints through `ctx.print`. The routing is unit-tested without a browser.
+import { theme } from './theme.js';
+/**
+ * Build the informational group. The handlers only gather + print; nothing
+ * here mutates session state.
+ */
+export function createInfoCommands(deps) {
+    const { t } = deps;
+    const printLines = (lines, print) => {
+        for (const line of lines)
+            print(theme.system(line));
+    };
+    return [
+        {
+            name: 'status',
+            handler: (ctx) => printLines(deps.statusLines(), ctx.print),
+        },
+        {
+            name: 'chat',
+            handler: async (ctx) => {
+                const id = deps.currentChatId();
+                if (id) {
+                    ctx.print(theme.system(t('chats.current_id', { v: id })));
+                    ctx.print(theme.system(`URL: ${deps.chatUrl(id)}`));
+                    return;
+                }
+                const live = await deps.resolveChatId();
+                ctx.print(theme.system(live ? t('chats.current_id', { v: live }) : t('chats.not_created')));
+            },
+        },
+        {
+            name: 'pwd',
+            handler: (ctx) => ctx.print(theme.system(deps.workdir())),
+        },
+        {
+            name: 'transcript',
+            handler: (ctx) => ctx.print(theme.system(deps.transcriptFile() || t('common.off'))),
+        },
+        {
+            name: 'cost',
+            aliases: ['usage'],
+            handler: async (ctx) => printLines(await deps.costReport(), ctx.print),
+        },
+        {
+            name: 'limits',
+            handler: async (ctx) => printLines(await deps.limitsReport(), ctx.print),
+        },
+        {
+            name: 'memory',
+            handler: async (ctx) => printLines(await deps.memoryReport(), ctx.print),
+        },
+        {
+            name: 'skills',
+            handler: async (ctx) => printLines(await deps.skillsReport(), ctx.print),
+        },
+    ];
+}

package/dist/input/layout.js

@@ -362,6 +362,32 @@ export function truncateToWidth(s, maxCols) {
 export function inputInnerCols(cols, borderCols = 2) {
     return Math.max(4, (Number(cols) || 80) - borderCols - 2);
 }
+/**
+ * Horizontal gutter (columns on EACH side) that the full-screen layout keeps
+ * free so the UI does not hug the terminal edges. The operator asked for it: on
+ * a 170-column terminal the header, the answers and the input box were pinned
+ * to column 0 with nothing breathing around them.
+ *
+ * A gutter is dropped entirely on a narrow terminal (< GUTTER_MIN_COLS): the
+ * panes would otherwise lose more width than they gain in looks, and a deep
+ * workdir in the header already competes for the same row.
+ */
+export const GUTTER_MIN_COLS = 60;
+export function screenGutter(cols) {
+    const c = Math.max(1, Math.floor(Number(cols) || 80));
+    return c >= GUTTER_MIN_COLS ? 2 : 0;
+}
+/**
+ * Inner width of a full-screen pane: the terminal minus the gutter on BOTH
+ * sides. One helper so the header, the log, the status bar and the input box
+ * wrap and truncate to the SAME width — a mismatch is exactly the class of bug
+ * that clipped an input row or wrapped a header title onto a second line.
+ */
+export function screenInnerCols(cols) {
+    const c = Math.max(1, Math.floor(Number(cols) || 80));
+    const g = screenGutter(c);
+    return Math.max(4, c - g * 2);
+}
 // Real height (rows) of the framed input box for the CURRENT buffer: 2 border
 // rows + the number of VISUAL rows the buffer wraps to. Using the LOGICAL line
 // count (buf.split('\n').length) was wrong: a long line wraps and renders MORE
@@ -421,10 +447,21 @@ export function layoutInput(promptStr, buf, cursor, cols) {
         const atLineEnd = i >= chars.length || chars[i] === NL;
         if (!atLineEnd && widthUsed >= avail && lastSpace > 0) {
             // Move the "tail" of the line to the next visual line.
+            //
+            // The break happens AT a space, and that space belongs to neither row:
+            // it is the wrap point. Leaving it in `text` printed a trailing space at
+            // the end of the first row, and leaving it in the tail printed a LEADING
+            // space on the continuation row (`❯ ф вйцв …` / `   йца …` — the
+            // operator saw the extra indent on every wrapped line). Consume it.
             const textChars = Array.from(text);
-            const tailLen = textChars.length - lastSpace;
+            const tailLen = textChars.length - lastSpace - 1;
             i -= tailLen;
             text = textChars.slice(0, lastSpace).join('');
+            // Skip the space itself so the next row starts at the word.
+            i += 0;
+            // `text` may still contain the space as its LAST char when the break
+            // lands right after it; trim it (the row must not end with blank space).
+            text = text.replace(/ +$/, '');
         }
         if (i < chars.length && chars[i] === NL) {
             i++;

package/dist/input.js

@@ -3,7 +3,7 @@ import { summarizeToolCall } from './tool-summary.js';
 import { renderMarkdown } from './markdown.js';
 import { contentWidth } from './width.js';
 import { randomThinkingPhrase, stripEllipsis, DOTS, renderDots, } from './spinner.js';
-import { translate } from './i18n.js';
+import { translate, DEFAULT_LOCALE } from './i18n.js';
 import { AttachmentStore, parseImagePaste, looksLikeFilePath, } from './attachments.js';
 import { NL, CR, ESC, PASTE_START, PASTE_END, SUGGEST_PAGE, pasteReplacement, expandPastes, safeJson, visRows, visLen, charWidth, layoutInput, formatTokenStatus, tokenStatusLevel, truncateToWidth, wrapToWidth, splitPasteTail, CONTEXT_LIMIT, } from './input/layout.js';
 // The pure layout/formatting helpers (visual rows, cursor position, visible
@@ -197,7 +197,7 @@ export class LineEditor {
     // as a mutable field (set from config.ui.contextLimit) so the status bar
     // reflects the real limit instead of a hardcoded constant.
     contextLimit;
-    constructor({ prompt = '> ', commands = [], locale = 'ru', } = {}) {
+    constructor({ prompt = '> ', commands = [], locale = DEFAULT_LOCALE, } = {}) {
         this.locale = locale;
         this.promptStr = prompt;
         this.buf = '';

package/dist/password-store.js

@@ -0,0 +1,48 @@
+// N21: WHERE a provider password is stored.
+//
+// Today `browser.auth.password` sits in `~/.zames/config.json` as plain text
+// (the file is 0600, which is not encryption). This module owns the DECISION —
+// a pure function, so the choice is testable without touching a keychain:
+//
+//  - `none`      — do not store the password at all; the session lives in the
+//                  browser profile and the password is asked for only when that
+//                  session is gone.
+//  - `keychain`  — an external OS tool (`secret-tool` on Linux Secret Service,
+//                  `security` on macOS, PowerShell Credential Manager on
+//                  Windows). No native npm dependency.
+//  - `config`    — the historical plain-text field (the fallback).
+//
+// The MIGRATION is explicit: an existing plain password is moved to the chosen
+// store and the config field is cleared, never silently duplicated.
+/**
+ * The store that can actually be used right now. `preferred` comes from the
+ * operator (`browser.passwordStore`); when it is `keychain` but no tool exists,
+ * the caller falls back to `config` WITH a warning — the password must never
+ * be silently dropped.
+ */
+export function resolvePasswordStore(preferred, probe) {
+    if (preferred !== 'keychain')
+        return { store: preferred, degraded: false };
+    const available = (probe.platform === 'linux' && probe.secretTool) ||
+        (probe.platform === 'darwin' && probe.security) ||
+        (probe.platform === 'win32' && probe.powershell);
+    if (available)
+        return { store: 'keychain', degraded: false };
+    return { store: 'config', degraded: true };
+}
+export function planPasswordMigration(existing, store, degraded) {
+    const has = !!(existing && existing.trim());
+    if (!has)
+        return { keychainWrite: null, clearConfig: false, warn: degraded };
+    if (store === 'none') {
+        return { keychainWrite: null, clearConfig: true, warn: degraded };
+    }
+    if (store === 'keychain') {
+        return { keychainWrite: existing, clearConfig: true, warn: degraded };
+    }
+    return { keychainWrite: null, clearConfig: false, warn: degraded };
+}
+/** The account name used inside the OS store (one entry per provider). */
+export function keychainAccount(provider) {
+    return 'zames:' + provider;
+}

package/dist/prompt-budget.js

@@ -0,0 +1,23 @@
+// N6/N12: the SYSTEM PROMPT BUDGET.
+//
+// The system prompt is sent into EVERY new chat, so it silently eats the web
+// chat's context window before the first task line. `test/system-prompt-size`
+// pins the default size; `/doctor` and `/context` report it in KB, with a
+// warning above the same threshold. One constant for all three, so a raised
+// budget is a deliberate edit here with a reason, not an accident.
+/** Measured ~21.9 KB for the full default tool set (subagents on). */
+export const SYSTEM_PROMPT_BUDGET_BYTES = 24000;
+/**
+ * The project-context files (AGENTS.md / MEMORY.md) load into the same
+ * prompt. A single huge file is the most common reason for a blown budget, so
+ * the CONTEXT budget is reported next to the prompt one.
+ */
+export const CONTEXT_BUDGET_BYTES = 120000;
+/** kB with one decimal, for a human-facing report. */
+export function kb(bytes) {
+    return (bytes / 1024).toFixed(1) + ' KB';
+}
+/** True when the size is above the budget (a WARN in /doctor). */
+export function overBudget(bytes, budget) {
+    return bytes > budget;
+}

package/dist/provider-errors.js

@@ -0,0 +1,53 @@
+// N1 stage 2: the error families shared by the chat providers.
+//
+// Each provider used to declare its own copy (`QwenRateLimitError`,
+// `GlmRateLimitError`, ...), so the retry policy in every `ask()` re-listed the
+// same six families and a new one had to be added three times. The classes
+// here are the SHARED vocabulary; the provider keeps its own pre-check
+// (`instanceof`) only where the semantics genuinely differ (guest limits and
+// the age gate exist on one backend only).
+//
+// `provider` is carried for the operator-facing message only — the retry
+// decision is per CLASS, never per string.
+export class ProviderRateLimitError extends Error {
+    constructor(detail) {
+        super('rate limit: ' + detail);
+        this.name = 'ProviderRateLimitError';
+    }
+}
+export class ProviderServerBusyError extends Error {
+    constructor(detail) {
+        super('server busy: ' + detail);
+        this.name = 'ProviderServerBusyError';
+    }
+}
+export class ProviderContextLimitError extends Error {
+    constructor(detail) {
+        super('context limit: ' + detail);
+        this.name = 'ProviderContextLimitError';
+    }
+}
+export class ProviderIncompleteError extends Error {
+    constructor(detail) {
+        super('generation incomplete: ' + detail);
+        this.name = 'ProviderIncompleteError';
+    }
+}
+export class ProviderGuestLimitError extends Error {
+    constructor(detail) {
+        super('guest limit: ' + detail);
+        this.name = 'ProviderGuestLimitError';
+    }
+}
+export class ProviderAgeGateError extends Error {
+    constructor(detail) {
+        super('age gate: ' + detail);
+        this.name = 'ProviderAgeGateError';
+    }
+}
+export class ProviderCaptchaError extends Error {
+    constructor(detail) {
+        super('captcha: ' + detail);
+        this.name = 'ProviderCaptchaError';
+    }
+}

package/dist/provider-fallback.js

@@ -0,0 +1,46 @@
+// N8: the FALLBACK-PROVIDER decision as a PURE function.
+//
+// When the active backend exhausted its retries (rate limit / server busy /
+// an unrecoverable send), the task used to stop even though `/provider` and
+// the existing handoff machinery could continue it on another chat. A
+// candidate is usable ONLY when it is a different, AUTHORIZED provider: a
+// marker in `~/.zames/auth.json` AND a confirmed login (`probeLogin()`). Guest
+// mode is never a fallback — a guest gets a handful of turns a day (Qwen) and
+// GLM gates the first send with a captcha, so the task would die a few steps
+// later, in a worse place.
+//
+// Everything here is data-in, decision-out: the caller supplies the auth
+// marker text, the config flag and the async login probe.
+/**
+ * Pick the first usable fallback provider.
+ *
+ * `hasMarker(id, raw)` is injected (authMarkerHas) so this module stays free
+ * of the marker format; `probeLogin(id)` confirms the stored session really
+ * works — a marker without a live session is useless (the switch would land on
+ * a login page mid-task).
+ */
+export async function pickFallbackProvider(active, candidates, probeLogin, hasMarker) {
+    const authorizable = [];
+    for (const c of candidates) {
+        if (c.id === active)
+            continue;
+        // A live GUEST session is not a fallback (it dies in a few turns), but the
+        // provider is still authorizable — signing in makes it a candidate.
+        if (c.guestAllowed && c.guestSession !== false) {
+            authorizable.push(c.id);
+            continue;
+        }
+        const marker = hasMarker(c.authMarker, c.id);
+        if (!marker) {
+            authorizable.push(c.id);
+            continue;
+        }
+        const ok = await probeLogin(c.id).catch(() => false);
+        if (ok)
+            return { provider: c.id, authorizable };
+        // A stale marker is NOT authorizable in place: the session must be renewed
+        // interactively, which this path must not start mid-task.
+        authorizable.push(c.id);
+    }
+    return { provider: null, authorizable };
+}