zames_pro 2.55.0 → 2.59.0

package/dist/spinner.js

@@ -27,6 +27,9 @@ export function renderDots(n) {
     return theme.brown(d + DOTS_PAD.slice(d.length));
 }
 export function createSpinner(locale = 'ru') {
+    // Set by the caller (index.ts) to the same todos summary the LineEditor
+    // shows, so the non-TTY path has parity.
+    let onTasksQuery = null;
     let spinner = null;
     let dotTimer = null;
     let dotPhase = 0;
@@ -37,6 +40,10 @@ export function createSpinner(locale = 'ru') {
     // zero every second and look frozen on a single dot.
     let animBase = '';
     let animating = false;
+    // When the current animated phase began, so a long reasoning turn can show
+    // "12s" / "2m 05s" instead of looking identical to a hung one. Parity with
+    // the LineEditor status line (src/input.ts).
+    let animStart = 0;
     const start = (text) => {
         if (!spinner)
             spinner = ora(text).start();
@@ -59,9 +66,34 @@ export function createSpinner(locale = 'ru') {
     // "running" dot sequence. Shared by the thinking spinner and the send-pause
     // indicator, so the pause is animated too (before, it was a static line and
     // the dots did not move — the operator saw a frozen spinner).
+    // Elapsed label of the current animated phase ("0s", "45s", "2m 05s").
+    // Empty when nothing is animating. Localized units come from the catalog.
+    const elapsedLabel = () => {
+        if (!animating || !animStart)
+            return '';
+        const sec = Math.floor((Date.now() - animStart) / 1000);
+        const m = Math.floor(sec / 60);
+        const s = sec % 60;
+        const text = m > 0 ? m + 'm ' + String(s).padStart(2, '0') + 's' : s + 's';
+        return theme.dim(' · ' + text);
+    };
+    // Task-list badge, refreshed from onTasksQuery on every animation tick.
+    // Mirrors the LineEditor so the non-TTY spinner shows the same "tasks: 2/5".
+    const tasksBadge = () => {
+        if (!onTasksQuery)
+            return '';
+        try {
+            const s = onTasksQuery();
+            return s ? theme.system(s) + ' ' : '';
+        }
+        catch {
+            return '';
+        }
+    };
     const startAnimated = (baseText) => {
         animBase = theme.brown(stripEllipsis(baseText));
-        start(animBase + renderDots(0) + HINT);
+        animStart = Date.now();
+        start(animBase + renderDots(0) + elapsedLabel() + tasksBadge() + HINT);
         dotPhase = 0;
         if (dotTimer)
             clearInterval(dotTimer);
@@ -69,7 +101,8 @@ export function createSpinner(locale = 'ru') {
             if (!spinner)
                 return;
             dotPhase = (dotPhase + 1) % DOTS.length;
-            spinner.text = animBase + renderDots(dotPhase) + HINT;
+            spinner.text =
+                animBase + renderDots(dotPhase) + elapsedLabel() + tasksBadge() + HINT;
         }, 400);
         animating = true;
         if (dotTimer.unref)
@@ -93,6 +126,12 @@ export function createSpinner(locale = 'ru') {
         spinner.text = theme.prompt('✎ ') + pending + HINT;
     };
     return {
+        get onTasksQuery() {
+            return onTasksQuery;
+        },
+        set onTasksQuery(fn) {
+            onTasksQuery = fn;
+        },
         thinking: () => {
             if (pending) {
                 showPending();
@@ -112,7 +151,7 @@ export function createSpinner(locale = 'ru') {
             // so the countdown refreshes without resetting the dots.
             if (animating && dotTimer && spinner) {
                 animBase = theme.brown(stripEllipsis(label));
-                spinner.text = animBase + renderDots(dotPhase) + HINT;
+                spinner.text = animBase + renderDots(dotPhase) + elapsedLabel() + HINT;
                 return;
             }
             startAnimated(label);

package/dist/system-prompt.js

@@ -128,6 +128,19 @@ You have access to the following tools:
 
 ${toolDescriptions}
 ${gitSection}${attachSection}${contextSection}
+## Choosing the right tool
+
+Prefer the most specific tool; a wrong choice wastes a turn:
+
+- Several small edits in ONE file -> MultiEdit (applied atomically), not
+  several Edit calls.
+- Changes across SEVERAL files -> ApplyPatch (V4A), not a series of writes.
+- One exact replacement -> Edit. Creating or overwriting a whole file -> Write.
+- Searching file CONTENT -> Grep; finding files by NAME -> Glob; listing a
+  directory -> LS.
+- Git operations -> the Git* tools, not Bash.
+- Reading a file whose path you already know -> Read, not Bash cat.
+
 ## MCP tools
 
 Some tools are provided by external MCP servers and their names look

package/dist/tools.js

@@ -8,7 +8,7 @@ import { createExtraTools } from './extraTools.js';
 // user-facing. They must be in ENGLISH (like Claude Code / Codex). Only the
 // strings the OPERATOR sees (help, spinner, service messages) are localized —
 // those live in src/i18n.ts (CATALOG) and are picked by the locale setting.
-export function createTools(workdir, { undo, todos } = {}) {
+export function createTools(workdir, { undo, todos, readOnly = false, } = {}) {
     const root = path.resolve(workdir);
     const safe = (p) => {
         const resolved = path.resolve(root, p);
@@ -164,7 +164,8 @@ export function createTools(workdir, { undo, todos } = {}) {
         {
             name: 'Grep',
             description: 'Search file contents (regular expression). include — file name ' +
-                'filter (e.g. "*.ts"). output: content (default, matching lines with ' +
+                'filter, a single glob or a comma-separated list (e.g. "*.ts" or ' +
+                '"*.ts,*.tsx"). output: content (default, matching lines with ' +
                 'numbers), files_only (paths only), count (match count per file).',
             parameters: {
                 pattern: 'string',
@@ -175,7 +176,11 @@ export function createTools(workdir, { undo, todos } = {}) {
             fn: async ({ pattern, path: searchPath, include, output }) => {
                 const pat = req(pattern, 'pattern');
                 const target = searchPath ? safe(String(searchPath)) : workdir;
-                const inc = include ? String(include).trim() : '';
+                // include may be a single glob or a comma-separated list.
+                const incs = (include ? String(include) : '')
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean);
                 const mode = String(output || 'content').toLowerCase();
                 if (process.platform === 'win32') {
                     const escaped = pat.replace(/"/g, '\\"');
@@ -183,7 +188,9 @@ export function createTools(workdir, { undo, todos } = {}) {
                     return runShell(workdir, `findstr /s /n /r /c:"${escaped}" ` + scope);
                 }
                 const flags = mode === 'files_only' ? '-rlE' : mode === 'count' ? '-rcE' : '-rnE';
-                const includeArg = inc ? ' --include=' + JSON.stringify(inc) : '';
+                const includeArg = incs
+                    .map((g) => ' --include=' + JSON.stringify(g))
+                    .join('');
                 return runShell(workdir, `grep ${flags}${includeArg} ${JSON.stringify(pat)} ` +
                     `${JSON.stringify(target)} || true`);
             },
@@ -198,5 +205,31 @@ export function createTools(workdir, { undo, todos } = {}) {
         parameters: { message: 'string' },
         fn: async ({ message }) => message,
     };
-    return [...baseTools, ...extraTools, ...gitTools, ...webTools, respondTool];
+    const all = [
+        ...baseTools,
+        ...extraTools,
+        ...gitTools,
+        ...webTools,
+        respondTool,
+    ];
+    return readOnly ? filterToolsForReadOnly(all) : all;
+}
+// Tools that mutate the working tree or run arbitrary commands. In "plan"
+// (read-only) mode they are REMOVED from the tool set entirely, so the model
+// cannot write by accident while it is still investigating. Removing (rather
+// than rejecting at call time) is the honest signal: the agent never sees a
+// tool it is not allowed to use, so it does not waste a turn trying.
+export const MUTATING_TOOLS = new Set([
+    'Write',
+    'Edit',
+    'MultiEdit',
+    'ApplyPatch',
+    'Bash',
+    'GitAdd',
+    'GitCommit',
+    'GitPush',
+]);
+/** Drop mutating tools for read-only / plan mode. Pure; unit-tested. */
+export function filterToolsForReadOnly(tools) {
+    return tools.filter((t) => !MUTATING_TOOLS.has(t.name));
 }

package/dist/transcript.js

@@ -5,11 +5,13 @@ export class Transcript {
     file;
     stream;
     startedAt;
-    constructor({ dir, enabled = true, sessionName = 'session', }) {
+    onLine;
+    constructor({ dir, enabled = true, sessionName = 'session', onLine = null, }) {
         this.enabled = enabled;
         this.file = null;
         this.stream = null;
         this.startedAt = Date.now();
+        this.onLine = onLine;
         if (!enabled)
             return;
         try {
@@ -30,16 +32,24 @@ export class Transcript {
         }
     }
     log(type, data = {}) {
-        if (!this.enabled || !this.stream)
-            return;
         const entry = {
             ts: new Date().toISOString(),
             elapsed: Date.now() - this.startedAt,
             type,
             ...data,
         };
+        const line = JSON.stringify(entry) + String.fromCharCode(10);
+        // The mirror runs even when the file is disabled (jsonl mode).
+        if (this.onLine) {
+            try {
+                this.onLine(line);
+            }
+            catch { }
+        }
+        if (!this.enabled || !this.stream)
+            return;
         try {
-            this.stream.write(JSON.stringify(entry) + String.fromCharCode(10));
+            this.stream.write(line);
         }
         catch { }
     }

package/dist/undo.js

@@ -1,6 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
+import { writeJsonAtomic } from './fsutil.js';
 const UNDO_DIR = path.join(os.homedir(), '.zames', 'undo');
 const INDEX = path.join(UNDO_DIR, 'index.json');
 export class UndoStore {
@@ -23,9 +24,7 @@ export class UndoStore {
     }
     async _writeIndex(history) {
         // Atomic write: a crash mid-write must not corrupt the undo history.
-        const tmp = `${INDEX}.tmp-${process.pid}`;
-        await fs.writeFile(tmp, JSON.stringify(history, null, 2));
-        await fs.rename(tmp, INDEX);
+        writeJsonAtomic(INDEX, history);
     }
     async backup(filePath) {
         if (!this.enabled)
@@ -63,15 +62,18 @@ export class UndoStore {
         return { originalPath: filePath, existed, stamp };
     }
     async undoLast() {
+        // Machine codes, NOT prose: the caller (index.ts) localizes them through
+        // the i18n catalog. Hardcoding a Russian reason here leaked Russian into
+        // an English UI (`/undo` with an empty history).
         if (!this.enabled)
-            return { ok: false, reason: 'undo отключён в конфиге' };
+            return { ok: false, reason: 'disabled' };
         await this._ensure();
         const history = await this._readIndex();
         if (!history.length)
-            return { ok: false, reason: 'история пуста' };
+            return { ok: false, reason: 'empty' };
         const record = history.pop();
         if (!record)
-            return { ok: false, reason: 'история пуста' };
+            return { ok: false, reason: 'empty' };
         const { originalPath, existed, backupFile } = record;
         try {
             if (existed && backupFile) {

package/dist/web.js

@@ -118,6 +118,30 @@ async function assertPublicUrl(rawUrl) {
     }
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// True for content types whose bodies are not meant to be shown as text.
+// WebFetch dumps the body into the context, so a PDF or an image would flood
+// the model with garbage; the caller returns a short human note instead.
+export function isBinaryContentType(contentType) {
+    const ct = String(contentType || '')
+        .toLowerCase()
+        .split(';')[0]
+        .trim();
+    if (!ct)
+        return false;
+    if (ct.startsWith('text/'))
+        return false;
+    // Textual application/* types must stay readable.
+    if (/^(application\/(json|xml|xhtml\+xml|javascript|ecmascript|x-httpd-php|rtf|sql|graphql|x-sh|x-yaml|yaml|toml|ld\+json|x-ndjson))$/.test(ct)) {
+        return false;
+    }
+    if (/\+(json|xml)$/.test(ct))
+        return false;
+    if (/^(image|audio|video|font|model)\//.test(ct) ||
+        /^application\/(pdf|zip|gzip|x-gzip|x-tar|octet-stream|msword|vnd\.|x-7z|x-rar|x-bzip|x-protobuf|wasm)/.test(ct)) {
+        return true;
+    }
+    return false;
+}
 // fetch with retries for transient network errors and 5xx responses.
 async function httpFetchWithRetry(url, opts = {}, retries = 2) {
     let lastErr;
@@ -231,6 +255,13 @@ export function createWebTools() {
                         return formatResult(r.status, r.url, text, limit);
                     }
                     const r = await httpFetchWithRetry(String(url));
+                    // Binary content (PDF, images, archives, ...) must NOT be dumped
+                    // into the context as raw bytes — tell the model what it is instead.
+                    if (isBinaryContentType(r.contentType)) {
+                        return (`HTTP ${r.status}  ${r.url}\n` +
+                            `Content-Type: ${r.contentType}\n\n` +
+                            `(binary content is not returned as text; content-type: ${r.contentType})`);
+                    }
                     // If it's JSON/plain text — return as is
                     if (/application\/json|text\/plain|text\/markdown/i.test(r.contentType)) {
                         const trimmed = r.body.slice(0, limit);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zames_pro",
-  "version": "2.55.0",
-  "description": "Terminal coding agent over chat.deepseek.com via Playwright",
+  "version": "2.59.0",
+  "description": "Terminal coding agent that drives chat.deepseek.com through Playwright: reads and edits files, runs commands, commits to git.",
   "type": "module",
   "bin": {
     "zames": "dist/index.js"
@@ -10,13 +10,16 @@
     "dist",
     "scripts",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE",
     "logo.jpg"
   ],
   "scripts": {
     "start": "node ./dist/index.js",
     "dev": "ZAMES_NET_DEBUG=1 tsx ./src/index.ts --dev --headed",
-    "build": "tsc -p tsconfig.build.json",
+    "clean": "node scripts/clean-dist.mjs",
+    "build": "node scripts/clean-dist.mjs && tsc -p tsconfig.build.json",
+    "coverage:gate": "node scripts/coverage-gate.mjs",
     "typecheck": "tsc --noEmit",
     "lint": "node scripts/eslint-ts6.mjs",
     "lint:fix": "node scripts/eslint-ts6.mjs --fix",
@@ -34,7 +37,13 @@
     "ai",
     "deepseek",
     "cli",
-    "coding-agent"
+    "coding-agent",
+    "claude-code",
+    "codex",
+    "terminal",
+    "playwright",
+    "llm",
+    "automation"
   ],
   "license": "MIT",
   "engines": {

package/scripts/clean-dist.mjs

@@ -0,0 +1,17 @@
+import { rmSync, existsSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+// tsc emits into dist/ without clearing it, so a source file DELETED from
+// src/ leaves an orphan .js in the published tree (this really happened:
+// dist/confirm.js survived after src/confirm.ts was removed). Wipe dist/ first
+// so the build output mirrors src/ exactly.
+//
+// Cross-platform: use node's fs.rm instead of a shell `rm -rf` (Windows has no
+// rm) and never touch anything outside this repo.
+const here = path.dirname(fileURLToPath(import.meta.url))
+const dist = path.resolve(here, '..', 'dist')
+if (existsSync(dist)) {
+  rmSync(dist, { recursive: true, force: true })
+  console.log('clean-dist: removed', dist)
+}

package/scripts/coverage-gate.mjs

@@ -0,0 +1,83 @@
+import { spawnSync } from 'node:child_process'
+
+// Soft coverage FLOOR for the PURE logic modules — the ones a regression would
+// silently break without any UI symptom (command formatting, schedule parsing,
+// the raw SSE/model-answer parsing). The floors are deliberately a few points
+// BELOW the current values so ordinary churn does not fail the build; they
+// only catch a real drop (a module losing its tests).
+//
+// Node's test runner has no built-in coverage threshold, so we parse the
+// per-file line % from the coverage report it prints and compare here. This is
+// informational in the sense that the FLOORS are conservative, but a drop
+// below one is a hard failure.
+const FLOORS = {
+  'commands.ts': 85,
+  'scheduler.ts': 90,
+  'net-capture.ts': 90,
+  'xml-toolcall.ts': 90,
+  'diff.ts': 90,
+  'theme.ts': 95,
+  // Added later: core logic or already well-tested, so a silent regression
+  // that deletes their tests should be caught too. Floors sit a few points
+  // below the current values.
+  'extraTools.ts': 85,
+  'fsutil.ts': 90,
+  'sessions.ts': 90,
+  'context.ts': 85,
+  'markdown.ts': 90,
+  'tools.ts': 90,
+  'system-prompt.ts': 90,
+  'undo.ts': 85,
+}
+
+const run = spawnSync(
+  'npx',
+  ['tsx', '--test', '--experimental-test-coverage', 'test/*.test.ts'],
+  { encoding: 'utf-8', shell: process.platform === 'win32', maxBuffer: 1024 * 1024 * 64 },
+)
+
+const out = (run.stdout || '') + (run.stderr || '')
+
+if (run.status !== 0) {
+  console.error('coverage-gate: test run failed (exit ' + run.status + ')')
+  process.exit(1)
+}
+
+const linePct = new Map()
+for (const line of out.split('\n')) {
+  // Per-file rows look like:
+  //   ℹ  commands.ts      |  94.14 |  78.70 |  93.88 | 40-56 ...
+  const m = line.match(/^\s*\S?\s*([A-Za-z0-9._-]+\.ts)\s+\|\s+([\d.]+)\s+\|/)
+  if (m) linePct.set(m[1], Number(m[2]))
+}
+
+const failures = []
+for (const [file, floor] of Object.entries(FLOORS)) {
+  const pct = linePct.get(file)
+  if (pct === undefined) {
+    failures.push(file + ': no coverage row found')
+    continue
+  }
+  if (pct < floor) {
+    failures.push(file + ': ' + pct + '% < floor ' + floor + '%')
+  } else {
+    console.log('coverage-gate: ' + file + ' ' + pct + '% >= ' + floor + '%')
+  }
+}
+
+// Print the lowest-covered modules, so a dead or untested module is visible
+// in the CI log even when it has no floor yet. Informational only.
+const sorted = [...linePct.entries()].sort((a, b) => a[1] - b[1]).slice(0, 8)
+if (sorted.length) {
+  console.log('coverage-gate: lowest covered modules (informational):')
+  for (const [name, pct] of sorted) {
+    console.log('  ' + name + ' ' + pct + '%')
+  }
+}
+
+if (failures.length) {
+  console.error('coverage-gate: FAILED')
+  for (const f of failures) console.error('  ' + f)
+  process.exit(1)
+}
+console.log('coverage-gate: OK')