zames_pro 2.13.0 → 2.15.0

package/dist/system-prompt.js

@@ -50,7 +50,7 @@ export function renderContextSection(context) {
 export function buildSystemPrompt({ workdir, tools, gitContext = null, locale = 'ru', attachments = [], context = null, }) {
     const t = translate(locale);
     const toolDescriptions = tools
-        .map((t2) => `### ${t2.name}\n${t2.description}\nПараметры: ${JSON.stringify(t2.parameters)}`)
+        .map((t2) => `### ${t2.name}\n${t2.description}\nParameters: ${JSON.stringify(t2.parameters)}`)
         .join('\n\n');
     const gitSection = gitContext
         ? `\n## Git context\n\n${gitContext}\n`

package/dist/tools.js

@@ -3,6 +3,11 @@ import path from 'path';
 import { exec } from 'child_process';
 import { createGitTools } from './gitTools.js';
 import { createWebTools } from './web.js';
+import { createExtraTools } from './extraTools.js';
+// NOTE: tool descriptions and tool-result strings are AGENT-FACING, not
+// 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 } = {}) {
     const root = path.resolve(workdir);
     const safe = (p) => {
@@ -11,7 +16,7 @@ export function createTools(workdir, { undo } = {}) {
         // (C:\work\proj vs C:\work\proj-old). We compute via relative().
         const rel = path.relative(root, resolved);
         if (rel.startsWith('..') || path.isAbsolute(rel)) {
-            throw new Error(`Доступ за пределы рабочей директории: ${p}`);
+            throw new Error(`Access outside the working directory is forbidden: ${p}`);
         }
         return resolved;
     };
@@ -28,7 +33,7 @@ export function createTools(workdir, { undo } = {}) {
             const target = path.resolve(root, raw);
             const rel = path.relative(root, target);
             if (rel.startsWith('..') || path.isAbsolute(rel)) {
-                throw new Error('Sandbox: выход за пределы ' + root + ' запрещён (cd ' + raw + ')');
+                throw new Error('Sandbox: leaving ' + root + ' is forbidden (cd ' + raw + ')');
             }
         }
     };
@@ -51,21 +56,21 @@ export function createTools(workdir, { undo } = {}) {
             const errStr = (stderr || '').toString();
             if (!err) {
                 const combined = (out + errStr).trim();
-                resolve(combined || '(команда выполнена без вывода)');
+                resolve(combined || '(command produced no output)');
                 return;
             }
             const parts = [];
             if (err.killed) {
-                parts.push(`⏱ Таймаут после ${timeout}ms — процесс убит.`);
+                parts.push(`⏱ Timeout after ${timeout}ms — process killed.`);
             }
             else if (err.code !== undefined && err.code !== null) {
                 parts.push(`Exit code: ${err.code}`);
             }
             else if (err.signal) {
-                parts.push(`Убит сигналом: ${err.signal}`);
+                parts.push(`Killed by signal: ${err.signal}`);
             }
             else {
-                parts.push(`Ошибка: ${err.message}`);
+                parts.push(`Error: ${err.message}`);
             }
             if (out.trim())
                 parts.push(`stdout:\n${out.trim()}`);
@@ -84,45 +89,76 @@ export function createTools(workdir, { undo } = {}) {
         }
         return String(content ?? '');
     };
+    // Guard against missing/placeholder required args. Without this, a tool call
+    // that omits `path` (or sends it as null) becomes String(undefined) ===
+    // "undefined" and the tool silently creates a file literally named
+    // "undefined" in the working directory. `req()` rejects that up front.
+    const req = (v, name) => {
+        if (v === undefined || v === null) {
+            throw new Error(`Missing required argument: ${name}`);
+        }
+        const s = String(v);
+        if (s === '' || s === 'undefined' || s === 'null') {
+            throw new Error(`Invalid required argument ${name}: ${JSON.stringify(v)}`);
+        }
+        return s;
+    };
     const baseTools = [
         {
             name: 'Read',
-            description: 'Прочитать содержимое файла. Опционально: offset и limit (строки).',
-            parameters: { path: 'string', offset: 'number?', limit: 'number?' },
-            fn: async ({ path: p, offset, limit }) => {
-                const file = safe(String(p));
+            description: 'Read a file. Optional: offset and limit (lines). ' +
+                'numbered=true adds cat -n style line numbers (1-based) for reference ' +
+                'only — do NOT copy the numbers into Edit old_string. ' +
+                'Lines longer than 2000 chars are truncated.',
+            parameters: {
+                path: 'string',
+                offset: 'number?',
+                limit: 'number?',
+                numbered: 'boolean?',
+            },
+            fn: async ({ path: p, offset, limit, numbered }) => {
+                const file = safe(req(p, 'path'));
                 const content = await fs.readFile(file, 'utf-8');
+                if (content === '')
+                    return '(file is empty)';
                 const lines = content.split('\n');
                 const start = offset ?? 0;
                 const end = limit ? start + limit : lines.length;
-                return lines.slice(start, end).join('\n');
+                const slice = lines.slice(start, end);
+                const clip = (l) => l.length > 2000 ? l.slice(0, 2000) + ' …[line truncated]' : l;
+                if (!numbered)
+                    return slice.map(clip).join('\n');
+                const width = String(start + slice.length).length;
+                return slice
+                    .map((l, i) => String(start + i + 1).padStart(width) + '\t' + clip(l))
+                    .join('\n');
             },
         },
         {
             name: 'Write',
-            description: 'Создать или перезаписать файл. content — текст; content_base64 — тот же ' +
-                'контент в base64 (используй, если текст содержит , обратные слэши, ' +
-                'переводы строк или другие символы, которые могут исказиться).',
+            description: 'Create or overwrite a file. content — text; content_base64 — the same ' +
+                'content base64-encoded (use it if the text contains $, backslashes, ' +
+                'newlines or other characters that may get corrupted in transit).',
             parameters: {
                 path: 'string',
                 content: 'string?',
                 content_base64: 'string?',
             },
             fn: async ({ path: p, content, content_base64 }) => {
-                const file = safe(String(p));
+                const file = safe(req(p, 'path'));
                 const text = decodeContent(content, content_base64);
                 if (undo)
                     await undo.backup(file);
                 await fs.mkdir(path.dirname(file), { recursive: true });
                 await fs.writeFile(file, text, 'utf-8');
-                return `Файл записан: ${p}`;
+                return `File written: ${p}`;
             },
         },
         {
             name: 'Edit',
-            description: 'Точечная замена строки в файле. old_string должен встречаться один раз. ' +
-                'old_base64/new_base64 — те же строки в base64 (если текст содержит ' +
-                'спецсимволы, которые могут исказиться).',
+            description: 'Replace a string in a file. old_string must occur exactly once. ' +
+                'old_base64/new_base64 — the same strings base64-encoded (if the text ' +
+                'contains special characters that may get corrupted).',
             parameters: {
                 path: 'string',
                 old_string: 'string?',
@@ -131,81 +167,99 @@ export function createTools(workdir, { undo } = {}) {
                 new_base64: 'string?',
             },
             fn: async ({ path: p, old_string, new_string, old_base64, new_base64 }) => {
-                const file = safe(String(p));
+                const file = safe(req(p, 'path'));
                 const oldStr = decodeContent(old_string, old_base64);
                 const newStr = decodeContent(new_string, new_base64);
                 if (oldStr === '') {
-                    throw new Error('old_string пустой — нечего заменять.');
+                    throw new Error('old_string is empty — nothing to replace.');
                 }
                 let content = await fs.readFile(file, 'utf-8');
                 const occurrences = content.split(oldStr).length - 1;
                 if (occurrences === 0) {
-                    throw new Error(`Строка не найдена в ${p}: "${oldStr.slice(0, 60)}..."`);
+                    throw new Error(`String not found in ${p}: "${oldStr.slice(0, 60)}..."`);
                 }
                 if (occurrences > 1) {
-                    throw new Error(`Строка встречается ${occurrences} раз в ${p}. Уточните old_string.`);
+                    throw new Error(`String occurs ${occurrences} times in ${p}. Make old_string more specific.`);
                 }
                 if (undo)
                     await undo.backup(file);
                 content = content.replace(oldStr, newStr);
                 await fs.writeFile(file, content, 'utf-8');
-                return `Отредактирован: ${p}`;
+                return `Edited: ${p}`;
             },
         },
         {
             name: 'Bash',
-            description: 'Выполнить shell-команду в рабочей директории (cmd.exe на Windows, sh на Linux/macOS). ' +
-                'Не использовать для long-running процессов (серверы) — уйдут в таймаут. ' +
-                'Не использовать для команд, требующих интерактивного ввода. ' +
-                'Для git — инструменты Git*. Для интернета — WebFetch / WebSearch.',
+            description: 'Run a shell command in the working directory (cmd.exe on Windows, sh on Linux/macOS). ' +
+                'Do not use for long-running processes (servers) — they will hit the timeout. ' +
+                'Do not use for commands that require interactive input. ' +
+                'For git use the Git* tools. For the web use WebFetch / WebSearch.',
             parameters: { command: 'string', timeout: 'number?' },
             fn: async ({ command, timeout }) => {
-                assertCommandInsideRoot(String(command));
-                return runShell(String(command), timeout);
+                assertCommandInsideRoot(req(command, 'command'));
+                return runShell(req(command, 'command'), timeout);
             },
         },
         {
             name: 'Glob',
-            description: 'Найти файлы по glob-паттерну (например, "**/*.js").',
-            parameters: { pattern: 'string' },
-            fn: async ({ pattern }) => {
+            description: 'Find files by glob pattern (e.g. "**/*.js"). ' +
+                'path (optional) — search directory inside the project.',
+            parameters: { pattern: 'string', path: 'string?' },
+            fn: async ({ pattern, path: searchPath }) => {
                 const { glob } = await import('fs/promises');
+                const cwd = searchPath ? safe(String(searchPath)) : workdir;
                 const results = [];
-                for await (const f of glob(String(pattern), { cwd: workdir })) {
+                for await (const f of glob(req(pattern, 'pattern'), { cwd })) {
                     // Sandbox: ignore anything that goes outside root.
-                    const abs = path.resolve(workdir, f);
+                    const abs = path.resolve(cwd, f);
                     const rel = path.relative(root, abs);
                     if (rel.startsWith('..') || path.isAbsolute(rel))
                         continue;
                     results.push(f);
                 }
-                return results.length ? results.join('\n') : 'Ничего не найдено.';
+                return results.length ? results.join('\n') : 'No matches found.';
             },
         },
         {
             name: 'Grep',
-            description: 'Поиск по содержимому файлов (регулярное выражение).',
-            parameters: { pattern: 'string', path: 'string?' },
-            fn: async ({ pattern, path: searchPath }) => {
+            description: 'Search file contents (regular expression). include — file name ' +
+                'filter (e.g. "*.ts"). output: content (default, matching lines with ' +
+                'numbers), files_only (paths only), count (match count per file).',
+            parameters: {
+                pattern: 'string',
+                path: 'string?',
+                include: 'string?',
+                output: 'string?',
+            },
+            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() : '';
+                const mode = String(output || 'content').toLowerCase();
                 if (process.platform === 'win32') {
-                    const escaped = String(pattern).replace(/"/g, '\\"');
-                    const scope = searchPath
-                        ? '"' + target + '\\*'
-                        : '*';
+                    const escaped = pat.replace(/"/g, '\\"');
+                    const scope = searchPath ? '"' + target + '\\*' : '*';
                     return runShell(`findstr /s /n /r /c:"${escaped}" ` + scope);
                 }
-                return runShell(`grep -rn -E ${JSON.stringify(pattern)} ${JSON.stringify(target)} || true`);
+                const flags = mode === 'files_only'
+                    ? '-rlE'
+                    : mode === 'count'
+                        ? '-rcE'
+                        : '-rnE';
+                const includeArg = inc ? ' --include=' + JSON.stringify(inc) : '';
+                return runShell(`grep ${flags}${includeArg} ${JSON.stringify(pat)} ` +
+                    `${JSON.stringify(target)} || true`);
             },
         },
     ];
     const gitTools = createGitTools(workdir);
     const webTools = createWebTools();
+    const extraTools = createExtraTools(workdir, { undo });
     const respondTool = {
         name: 'respond',
-        description: 'Дать финальный ответ пользователю и завершить задачу.',
+        description: 'Give the final answer to the user and finish the task.',
         parameters: { message: 'string' },
         fn: async ({ message }) => message,
     };
-    return [...baseTools, ...gitTools, ...webTools, respondTool];
+    return [...baseTools, ...extraTools, ...gitTools, ...webTools, respondTool];
 }

package/dist/web.js

@@ -112,9 +112,9 @@ export function createWebTools() {
     return [
         {
             name: 'WebFetch',
-            description: 'Загрузить URL и вернуть очищенный текст страницы (без HTML-тегов). ' +
-                'Используй для чтения документации, статей, README на GitHub. ' +
-                'Если страница рендерится JavaScript-ом и текст пустой — попробуй ещё раз с render=true.',
+            description: 'Fetch a URL and return the cleaned text of the page (without HTML tags). ' +
+                'Use it to read docs, articles, READMEs on GitHub. ' +
+                'If the page is rendered by JavaScript and the text is empty — retry with render=true.',
             parameters: {
                 url: 'string',
                 render: 'boolean?',
@@ -122,7 +122,7 @@ export function createWebTools() {
             },
             fn: async ({ url, render, maxChars }) => {
                 if (!/^https?:\/\//i.test(String(url))) {
-                    return `Ошибка: URL должен начинаться с http:// или https://`;
+                    return `Error: URL must start with http:// or https://`;
                 }
                 const limit = Math.min(Number(maxChars) || MAX_TEXT, 60_000);
                 try {
@@ -143,21 +143,21 @@ export function createWebTools() {
                     if (text.length < 200) {
                         return (`HTTP ${r.status}  ${r.url}\n` +
                             `Content-Type: ${r.contentType}\n\n` +
-                            `Страница почти пустая в сыром HTML (${text.length} символов). ` +
-                            `Похоже, контент рендерится JavaScript-ом. ` +
-                            `Повтори вызов с render=true.\n\n---\n${text}`);
+                            `The page is almost empty in raw HTML (${text.length} chars). ` +
+                            `It looks like the content is rendered by JavaScript. ` +
+                            `Retry with render=true.\n\n---\n${text}`);
                     }
                     return formatResult(r.status, r.url, text, limit);
                 }
                 catch (e) {
-                    return `Ошибка загрузки ${url}: ${e.message}`;
+                    return `Error fetching ${url}: ${e.message}`;
                 }
             },
         },
         {
             name: 'WebSearch',
-            description: 'Поиск в интернете через DuckDuckGo HTML (без API-ключа). ' +
-                'Возвращает список результатов: заголовок, URL, краткое описание.',
+            description: 'Search the web via DuckDuckGo HTML (no API key). ' +
+                'Returns a list of results: title, URL, short description.',
             parameters: {
                 query: 'string',
                 maxResults: 'number?',
@@ -165,7 +165,7 @@ export function createWebTools() {
             fn: async ({ query, maxResults }) => {
                 const q = encodeURIComponent(String(query || ''));
                 if (!q)
-                    return 'Ошибка: query пустой.';
+                    return 'Error: query is empty.';
                 const limit = Math.min(Math.max(Number(maxResults) || 8, 1), 20);
                 try {
                     const r = await httpFetch(`https://html.duckduckgo.com/html/?q=${q}`, {
@@ -175,7 +175,7 @@ export function createWebTools() {
                         },
                     });
                     if (r.status !== 200) {
-                        return `DuckDuckGo вернул HTTP ${r.status}`;
+                        return `DuckDuckGo returned HTTP ${r.status}`;
                     }
                     // We parse with simple regexes. The html.duckduckgo.com format is stable.
                     const results = [];
@@ -194,14 +194,14 @@ export function createWebTools() {
                         results.push({ title, url: href, snippet });
                     }
                     if (!results.length) {
-                        return `Результатов не найдено. Возможно, изменился формат выдачи DuckDuckGo.`;
+                        return `No results found. The DuckDuckGo output format may have changed.`;
                     }
                     const lines = results.map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}` +
                         (r.snippet ? `\n   ${r.snippet}` : ''));
                     return lines.join('\n\n');
                 }
                 catch (e) {
-                    return `Ошибка поиска: ${e.message}`;
+                    return `Search error: ${e.message}`;
                 }
             },
         },
@@ -215,5 +215,5 @@ function formatResult(status, url, text, limit) {
         truncated = true;
     }
     return (`HTTP ${status}  ${url}\n\n${out}` +
-        (truncated ? `\n\n[...обрезано на ${limit} символах]` : ''));
+        (truncated ? `\n\n[...truncated at ${limit} chars]` : ''));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.13.0",
+  "version": "2.15.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {