zames_pro 2.7.0 → 2.9.0

package/dist/index.js

@@ -7,7 +7,8 @@ import { DeepSeekBrowser } from './browser.js';
 import { createTools } from './tools.js';
 import { runAgentLoop } from './agent-loop.js';
 import { createSpinner } from './spinner.js';
-import { LineEditor } from './input.js';
+import { LineEditor, expandPastes, pasteReplacement } from './input.js';
+import { parseImagePaste, extForMime, saveToTemp, guessMime, isImageName, formatSize, looksLikeFilePath, readClipboardImageDetailed, sniffMime, readWindowsClipboardFiles, } from './attachments.js';
 import { loadConfig, DEFAULTS, CONFIG_PATHS, ZAMES_HOME, CONFIG_SCHEMA, getByPath, validateConfigValue, writeConfigValue, resetConfigValue, } from './config.js';
 import { runConfigMenu } from './config-menu.js';
 import { translate, normalizeLocale, localeDisplayName, isLocale, } from './i18n.js';
@@ -195,6 +196,7 @@ ${theme.bold(t('help.while_working'))}
   ${t('help.key.slash')}
   ${t('help.key.newline')}
   ${t('help.key.backslash')}
+  ${t('help.key.attach')}
   ${t('help.key.esc')}
 
 ${theme.bold(t('help.commands'))}
@@ -279,6 +281,27 @@ function buildSlashCommands() {
 // We put the agent's temporary files (one-off scripts, etc.) in
 // <project>/tmp — this folder is in .gitignore and is cleaned on every launch.
 const TMP_DIR = path.join(__dirname, '..', 'tmp');
+// Resolve a pasted string into a path to an existing file. Handles quoted
+// paths (drag&drop from some file managers adds quotes) and paths relative to
+// the working directory.
+async function resolveAttachPath(workdir, raw) {
+    let s = String(raw || '').trim();
+    if (!s)
+        return null;
+    if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+        s = s.slice(1, -1);
+    }
+    s = s.replace(/\\ /g, ' ');
+    if (!looksLikeFilePath(s) && !isImageName(s))
+        return null;
+    const candidates = path.isAbsolute(s) ? [s] : [path.resolve(workdir, s)];
+    for (const c of candidates) {
+        const st = await fs.stat(c).catch(() => null);
+        if (st && st.isFile())
+            return c;
+    }
+    return null;
+}
 async function cleanTmpDir() {
     try {
         await fs.rm(TMP_DIR, { recursive: true, force: true });
@@ -519,6 +542,8 @@ function watchInput({ onEscape, onChange, onQueue, } = {}) {
     process.stdout.write(ESC + '[?2004h');
     let buf = '';
     let inPaste = false;
+    let pasteBuf = '';
+    const pastes = [];
     const PASTE_START = ESC + '[200~';
     const PASTE_END = ESC + '[201~';
     const CSI_RE = new RegExp('^' + CSI + '[0-9;]*[A-Za-z~]');
@@ -526,8 +551,9 @@ function watchInput({ onEscape, onChange, onQueue, } = {}) {
         if (onChange)
             onChange(buf);
     };
-    // Pasted text: newlines inside a multiline paste are treated as spaces —
-    // the message goes as a single line.
+    // Pasted text: small pastes (1–2 lines) are flattened into one line;
+    // large ones (3+ lines) are collapsed into "[Pasted lines#N]" (the original
+    // text is expanded back when the message is queued).
     const insert = (text) => {
         buf += text
             .split(CR + LF)
@@ -537,6 +563,15 @@ function watchInput({ onEscape, onChange, onQueue, } = {}) {
             .split(LF)
             .join(' ');
     };
+    const insertPaste = (raw) => {
+        const rep = pasteReplacement(raw);
+        if (!rep) {
+            insert(raw);
+            return;
+        }
+        pastes.push(rep);
+        buf += rep.marker;
+    };
     function onData(data) {
         let s = data.toString('utf-8');
         // A single Esc — abort generation. Arrows come as a whole chunk and
@@ -550,13 +585,15 @@ function watchInput({ onEscape, onChange, onQueue, } = {}) {
             if (inPaste) {
                 const end = s.indexOf(PASTE_END);
                 if (end === -1) {
-                    insert(s);
+                    pasteBuf += s;
                     s = '';
                 }
                 else {
-                    insert(s.slice(0, end));
+                    pasteBuf += s.slice(0, end);
                     s = s.slice(end + PASTE_END.length);
                     inPaste = false;
+                    insertPaste(pasteBuf);
+                    pasteBuf = '';
                 }
                 emitChange();
                 continue;
@@ -566,6 +603,7 @@ function watchInput({ onEscape, onChange, onQueue, } = {}) {
                 const before = s.slice(0, start);
                 s = s.slice(start + PASTE_START.length);
                 inPaste = true;
+                pasteBuf = '';
                 if (before) {
                     insert(before);
                     emitChange();
@@ -576,8 +614,9 @@ function watchInput({ onEscape, onChange, onQueue, } = {}) {
             const code = s.charCodeAt(0);
             s = s.slice(1);
             if (ch === CR || ch === LF) {
-                const text = buf.trim();
+                const text = expandPastes(pastes, buf).trim();
                 buf = '';
+                pastes.length = 0;
                 emitChange();
                 if (text && onQueue)
                     onQueue(text);
@@ -592,6 +631,7 @@ function watchInput({ onEscape, onChange, onQueue, } = {}) {
             if (code === 21) {
                 // Ctrl+U — clear what was typed.
                 buf = '';
+                pastes.length = 0;
                 emitChange();
                 continue;
             }
@@ -638,7 +678,7 @@ async function resolveWorkdir() {
     return dir;
 }
 // ---------- task runner ----------
-async function runTask(browser, tools, taskText, workdir, opts) {
+async function runTask(browser, tools, taskText, workdir, opts, attachments = []) {
     const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor, onChatReady, } = opts;
     // In TTY mode the UI is a LineEditor: it owns the input (queue, Esc,
     // Ctrl+C) and draws the status ABOVE the permanent input line. In non-TTY
@@ -657,7 +697,7 @@ async function runTask(browser, tools, taskText, workdir, opts) {
             },
             onChange: (text) => ui.setPending(text),
             onQueue: (text) => {
-                queue.push(text);
+                queue.push({ text });
                 ui.setPending(null);
                 ui.stop();
                 console.log(theme.user(t('msg.queued', { n: queue.length })) +
@@ -666,7 +706,12 @@ async function runTask(browser, tools, taskText, workdir, opts) {
             },
         });
     try {
-        let next = { task: taskText, freshChat, sendSystemPrompt };
+        let next = {
+            text: taskText,
+            attachments,
+            freshChat,
+            sendSystemPrompt,
+        };
         // Execute the task, then everything the user managed to type while it
         // ran. The queue may be replenished right during draining.
         while (true) {
@@ -674,11 +719,12 @@ async function runTask(browser, tools, taskText, workdir, opts) {
             await mod.runAgentLoop({
                 browser,
                 tools,
-                task: next.task,
+                task: next.text,
                 workdir,
                 maxIterations: maxIter,
                 freshChat: next.freshChat,
                 sendSystemPrompt: next.sendSystemPrompt,
+                attachments: next.attachments || [],
                 transcript,
                 onThinking: () => ui.thinking(),
                 onToolCall: (name, toolArgs) => ui.toolCall(name, toolArgs),
@@ -697,16 +743,21 @@ async function runTask(browser, tools, taskText, workdir, opts) {
             }
             if (!queue.length)
                 break;
-            const queued = queue.shift() ?? '';
+            const queued = queue.shift() ?? { text: '' };
             ui.stop();
             if (editor) {
-                editor.printAbove(theme.user(t('msg.from_queue')) + theme.assistant(queued));
+                editor.printAbove(theme.user(t('msg.from_queue')) + theme.assistant(queued.text));
             }
             else {
-                console.log(theme.user(t('msg.from_queue')) + theme.assistant(queued));
-            }
-            transcript?.log('queued_task', { task: queued });
-            next = { task: queued, freshChat: false, sendSystemPrompt: false };
+                console.log(theme.user(t('msg.from_queue')) + theme.assistant(queued.text));
+            }
+            transcript?.log('queued_task', { task: queued.text });
+            next = {
+                text: queued.text,
+                attachments: queued.attachments,
+                freshChat: false,
+                sendSystemPrompt: false,
+            };
         }
     }
     catch (e) {
@@ -831,6 +882,10 @@ async function main() {
     // Messages the user typed while the agent worked. runTask takes them one
     // by one after the current task finishes.
     const pendingQueue = [];
+    // Attachments for the next submit (filled by the editor's onAttachments).
+    let pendingAttachments = [];
+    // Show the "no clipboard image" hint only once per session.
+    let clipboardWarned = false;
     // ---------- review mode state ----------
     // null — normal mode.
     // { snapDir, snapName, originalWorkdir } — we're inside a snapshot, the chat
@@ -905,8 +960,94 @@ async function main() {
             commands: buildSlashCommands(),
         });
         editor = ed;
-        ed.onSubmit = (text) => {
-            pendingQueue.push(text);
+        ed.setTmpDir(TMP_DIR);
+        ed.onAttach = async (raw) => {
+            // Case 1: the paste is the image data itself (data URL / base64 blob).
+            const image = parseImagePaste(raw);
+            if (image) {
+                const name = 'paste' + extForMime(image.mime);
+                const p = await saveToTemp(TMP_DIR, name, image.data);
+                const att = ed.attachments.add({
+                    path: p,
+                    name,
+                    mime: image.mime,
+                    size: image.data.length,
+                });
+                ed.printAbove(theme.system(t('msg.attached_image', { marker: att.marker, size: formatSize(image.data.length) })));
+                return att;
+            }
+            // Case 2: the paste is a path to a local file (drag&drop or copy path).
+            const filePath = await resolveAttachPath(currentWorkdir, raw);
+            if (!filePath)
+                return null;
+            const data = await fs.readFile(filePath).catch(() => null);
+            if (!data)
+                return null;
+            const name = path.basename(filePath);
+            const mime = guessMime(name);
+            const att = ed.attachments.add({
+                path: filePath,
+                name,
+                mime,
+                size: data.length,
+            });
+            ed.printAbove(theme.system(t('msg.attached_file', { marker: att.marker, name, size: formatSize(data.length) })));
+            return att;
+        };
+        ed.onClipboard = async () => {
+            const res = readClipboardImageDetailed();
+            if (!res.data || !res.data.length) {
+                // On WSL the user may have copied a FILE in Windows (not an image):
+                // the Windows clipboard holds its path - attach it directly.
+                for (const fp of readWindowsClipboardFiles()) {
+                    const data = await fs.readFile(fp).catch(() => null);
+                    if (!data)
+                        continue;
+                    const nm = path.basename(fp);
+                    const att = ed.attachments.add({
+                        path: fp,
+                        name: nm,
+                        mime: guessMime(nm),
+                        size: data.length,
+                    });
+                    ed.printAbove(theme.system(t('msg.attached_file', {
+                        marker: att.marker,
+                        name: nm,
+                        size: formatSize(data.length),
+                    }) + theme.dim(' (windows-clipboard)')));
+                    return att;
+                }
+                if (!clipboardWarned) {
+                    clipboardWarned = true;
+                    ed.printAbove(theme.warn(t('msg.clip_empty', { via: res.via }) +
+                        String.fromCharCode(10) +
+                        t('msg.clip_hint')));
+                }
+                return null;
+            }
+            const mime = sniffMime(res.data) || 'image/png';
+            const name = 'clipboard-' + Date.now() + (extForMime(mime) || '.png');
+            const p = await saveToTemp(TMP_DIR, name, res.data);
+            const att = ed.attachments.add({
+                path: p,
+                name,
+                mime,
+                size: res.data.length,
+            });
+            ed.printAbove(theme.system(t('msg.attached_image', {
+                marker: att.marker,
+                size: formatSize(res.data.length),
+            }) + theme.dim('  (' + res.via + ')')));
+            return att;
+        };
+        ed.onSubmit = (text, items) => {
+            const attachments = (items || []).map((a) => ({
+                path: a.path,
+                name: a.name,
+                mime: a.mime,
+            }));
+            const msg = { text, attachments };
+            pendingQueue.push(msg);
             if (waiter) {
                 const r = waiter;
                 waiter = null;
@@ -1159,10 +1300,13 @@ async function main() {
     }
     while (running) {
         let input;
+        let inputAttachments = [];
         try {
             if (editor) {
                 editor.setPrompt(buildPrompt());
-                input = await takeInput();
+                const msg = await takeInput();
+                input = msg ? msg.text : null;
+                inputAttachments = msg?.attachments || [];
             }
             else {
                 let tail;
@@ -1642,7 +1786,7 @@ async function main() {
                         saveLastChat(chatId, currentWorkdir);
                     }
                 },
-            });
+            }, inputAttachments);
         }
         finally {
             if (editor)

package/dist/input.js

@@ -1,6 +1,7 @@
 import { theme } from './theme.js';
 import { renderMarkdown } from './markdown.js';
 import { randomThinkingPhrase, stripEllipsis } from './spinner.js';
+import { AttachmentStore, parseImagePaste, looksLikeFilePath, } from './attachments.js';
 // A permanent input line at the bottom of the terminal + a status/output area above it.
 //
 // Why a custom editor:
@@ -27,6 +28,44 @@ const CR = String.fromCharCode(13);
 const ESC = String.fromCharCode(27);
 const PASTE_START = ESC + '[200~';
 const PASTE_END = ESC + '[201~';
+// A large paste (3+ lines) is collapsed in the input line into a short
+// marker "[Pasted lines#N]" so the line stays readable; the original text is
+// kept aside and expanded back on submit. Pastes of 1–2 lines are inserted
+// as-is (small pastes are usually short and don't clutter the line).
+export const PASTE_MIN_LINES = 3;
+// Number of lines in a pasted block (the trailing newline doesn't add a line).
+export function countPasteLines(raw) {
+    const normalized = String(raw).split(CR + NL).join(NL).split(CR).join(NL);
+    const trimmed = normalized.replace(/\n+$/, '');
+    if (trimmed === '')
+        return 1;
+    return trimmed.split(NL).length;
+}
+export function formatPasteMarker(lines) {
+    return '[Pasted lines#' + lines + ']';
+}
+// Decide how to represent a pasted block: null — insert as-is (small paste),
+// otherwise { marker, text }: the marker goes into the input line, and the
+// original text is expanded back on submit.
+export function pasteReplacement(raw) {
+    const text = String(raw).split(CR + NL).join(NL).split(CR).join(NL);
+    const lines = countPasteLines(text);
+    if (lines < PASTE_MIN_LINES)
+        return null;
+    return { marker: formatPasteMarker(lines), text };
+}
+// Replace "[Pasted lines#N]" markers with the original pasted text (the first
+// occurrence in order — matches the order in which the pastes were inserted).
+export function expandPastes(pastes, text) {
+    let out = text;
+    for (const p of pastes) {
+        const idx = out.indexOf(p.marker);
+        if (idx !== -1) {
+            out = out.slice(0, idx) + p.text + out.slice(idx + p.marker.length);
+        }
+    }
+    return out;
+}
 // Dot animation: start from an empty string (0 dots), then grow.
 // We align the width to the maximum (3) so the hint doesn't shift.
 const DOTS = ['', '.', '..', '...'];
@@ -156,6 +195,18 @@ export class LineEditor {
     // Slash-command hints (shown when you type «/»).
     slashCommands;
     _suggestCount;
+    // Pasted blocks collapsed into markers (expanded back on submit).
+    pastes;
+    _pasteBuf;
+    // Attached images/files (saved to <project>/tmp and sent to the chat).
+    attachments;
+    _tmpDir;
+    // Insert callback: receives a pasted image/file from the terminal. Returns
+    // the attachment if it was saved, so the editor can show a marker.
+    onAttach;
+    // Clipboard callback: tries to read an image from the OS clipboard when the
+    // terminal itself sends no usable data (Ctrl+V, right-click, empty paste).
+    onClipboard;
     constructor({ prompt = '> ', commands = [] } = {}) {
         this.promptStr = prompt;
         this.buf = '';
@@ -179,6 +230,29 @@ export class LineEditor {
         this._histDraft = '';
         this.slashCommands = commands;
         this._suggestCount = 0;
+        this.pastes = [];
+        this._pasteBuf = '';
+        this.attachments = new AttachmentStore();
+        this._tmpDir = '';
+        this.onAttach = null;
+        this.onClipboard = null;
+    }
+    // Read the OS clipboard for an image and insert its marker. Used when the
+    // terminal sends no usable paste data (Ctrl+V / right-click / empty paste).
+    async _tryClipboard() {
+        if (!this.onClipboard)
+            return;
+        try {
+            const att = await this.onClipboard();
+            if (att) {
+                this._insert(att.marker);
+                this._render();
+            }
+        }
+        catch { }
+    }
+    setTmpDir(dir) {
+        this._tmpDir = dir;
     }
     // List of hints for the current input. We show them only when the line
     // starts with «/» and is a single word (no spaces/newlines) — like
@@ -271,6 +345,7 @@ export class LineEditor {
     clear() {
         this.buf = '';
         this.cursor = 0;
+        this.pastes = [];
         this._render();
     }
     // ---------- rendering ----------
@@ -406,11 +481,14 @@ export class LineEditor {
     }
     // ---------- input ----------
     _submit() {
-        const text = this.buf;
-        if (!text.trim()) {
+        const display = this.buf;
+        if (!display.trim()) {
             this._render();
             return;
         }
+        // The input line shows compact markers "[Pasted lines#N]" instead of large
+        // pastes — expand them back into the original text before sending.
+        const text = expandPastes(this.pastes, display);
         // Add to history only non-empty messages that don't duplicate the previous one.
         if (text.trim() && this.history[this.history.length - 1] !== text) {
             this.history.push(text);
@@ -422,9 +500,14 @@ export class LineEditor {
         this.pendingText = null;
         this._stopDots();
         this.statusText = '';
-        this.printAbove(theme.user('❯ ') + text);
+        // Attachments collected for this message (images/files). They are handed
+        // to the browser layer to be attached to the chat.
+        const attached = this.attachments.items.slice();
+        this.printAbove(theme.user('❯ ') + display);
+        this.pastes = [];
+        this.attachments.reset();
         if (this.onSubmit)
-            this.onSubmit(text);
+            this.onSubmit(text, attached);
     }
     _insert(text) {
         const chars = Array.from(this.buf);
@@ -433,6 +516,53 @@ export class LineEditor {
         this.buf = next.join('');
         this.cursor += ins.length;
     }
+    // Insert a pasted block. Small pastes (1–2 lines) go in as-is; large ones
+    // (3+ lines) are collapsed into "[Pasted lines#N]" so the input line stays
+    // readable — the original text is expanded back on submit.
+    _insertPaste(raw) {
+        // A pasted image (a data URL / base64 blob) or a file path is saved to
+        // tmp and shown as [image#N] / [file#N] — the marker is attached to the
+        // message on submit.
+        if (this.onAttach) {
+            const asImage = parseImagePaste(raw);
+            const trimmed = String(raw).trim();
+            const isPath = !asImage && looksLikeFilePath(trimmed);
+            if (asImage || isPath) {
+                void this._attachAsync(raw);
+                return;
+            }
+        }
+        this._insertFallback(raw);
+    }
+    // Save a pasted image/file to tmp and put the [image#N]/[file#N] marker
+    // into the input line.
+    async _attachAsync(raw) {
+        if (!this.onAttach)
+            return;
+        try {
+            const att = await this.onAttach(raw);
+            if (att) {
+                this._insert(att.marker);
+                this._render();
+                return;
+            }
+        }
+        catch { }
+        // Attachment failed (e.g. the path does not exist) — insert the text as-is
+        // so nothing is lost.
+        this._insertFallback(raw);
+        this._render();
+    }
+    _insertFallback(raw) {
+        const rep = pasteReplacement(raw);
+        if (!rep) {
+            const text = String(raw).split(CR + NL).join(NL).split(CR).join(NL);
+            this._insert(text);
+            return;
+        }
+        this.pastes.push(rep);
+        this._insert(rep.marker);
+    }
     // Insert a newline. If the cursor is right after a «\»
     // (like in Claude Code), the character is removed — so «\» + Enter gives
     // an ordinary break without a stray backslash in the text.
@@ -595,13 +725,23 @@ export class LineEditor {
             if (this._inPaste) {
                 const end = s.indexOf(PASTE_END);
                 if (end === -1) {
-                    this._insert(s);
+                    // The paste arrived in several chunks — accumulate until the end marker.
+                    this._pasteBuf += s;
                     s = '';
                 }
                 else {
-                    this._insert(s.slice(0, end));
+                    this._pasteBuf += s.slice(0, end);
                     s = s.slice(end + PASTE_END.length);
                     this._inPaste = false;
+                    if (this._pasteBuf === '') {
+                        // Empty bracketed paste: many terminals send this for an image on
+                        // the clipboard (there is no text to deliver). Try the OS clipboard.
+                        void this._tryClipboard();
+                    }
+                    else {
+                        this._insertPaste(this._pasteBuf);
+                    }
+                    this._pasteBuf = '';
                 }
                 this._render();
                 continue;
@@ -611,6 +751,7 @@ export class LineEditor {
                 const before = s.slice(0, pasteAt);
                 s = s.slice(pasteAt + PASTE_START.length);
                 this._inPaste = true;
+                this._pasteBuf = '';
                 if (before) {
                     this._insert(before);
                     this._render();
@@ -699,9 +840,17 @@ export class LineEditor {
             if (code === 21) {
                 this.buf = '';
                 this.cursor = 0;
+                this.pastes = [];
                 this._render();
                 continue;
             }
+            if (code === 22) {
+                // Ctrl+V: terminals rarely deliver an image as text here, so we try the
+                // OS clipboard first; if there is no image we fall back to reading the
+                // text clipboard via the terminal's own paste (nothing to do).
+                void this._tryClipboard();
+                continue;
+            }
             if (code === 23) {
                 this._deleteWordLeft();
                 this._render();

package/dist/system-prompt.js

@@ -1,5 +1,5 @@
 import { translate } from './i18n.js';
-export function buildSystemPrompt({ workdir, tools, gitContext = null, locale = 'ru', }) {
+export function buildSystemPrompt({ workdir, tools, gitContext = null, locale = 'ru', attachments = [], }) {
     const t = translate(locale);
     const toolDescriptions = tools
         .map((t2) => `### ${t2.name}\n${t2.description}\nПараметры: ${JSON.stringify(t2.parameters)}`)
@@ -7,6 +7,10 @@ export function buildSystemPrompt({ workdir, tools, gitContext = null, locale =
     const gitSection = gitContext
         ? `\n## Git context\n\n${gitContext}\n`
         : '\n## Git context\n\nNot a git repository (or git is not installed).\n';
+    const attachSection = attachments.length
+        ? `\n## Attachments\n\nThe user attached files to this task: ${attachments.join(', ')}.\n` +
+            `Each [image#N] / [file#N] marker corresponds to a file the user pasted into the terminal; the file was uploaded to the chat and also saved under <project>/tmp. Look at the images in the chat; for files, read the copy in tmp if you need the contents.\n`
+        : '';
     return `You are a coding agent running in a terminal. You help the user with software engineering tasks by reading files, writing code, running commands, and iterating until the task is done.
 
 You work in the directory: ${workdir}
@@ -46,7 +50,7 @@ operator will not read it, so never use plain text.\n\nNO PROSE AROUND TOOL CALL
 You have access to the following tools:
 
 ${toolDescriptions}
-${gitSection}
+${gitSection}${attachSection}
 ## How to use tools
 
 To call ONE tool, respond with ONLY a JSON object (no markdown fences, no extra text):