zames_pro 1.2.1 → 2.1.0

package/dist/input.js

@@ -0,0 +1,523 @@
+import { theme } from './theme.js';
+import { renderMarkdown } from './markdown.js';
+import { randomThinkingPhrase, stripEllipsis } from './spinner.js';
+// Постоянная строка ввода внизу терминала + область статуса/вывода над ней.
+//
+// Зачем свой редактор:
+//   * строка ввода видна ВСЕГДА и не затирается выводом агента;
+//   * спиннер/статус и ответы печатаются ВЫШЕ строки ввода (printAbove);
+//   * перерисовка учитывает перенос по ширине терминала, поэтому нет
+//     дублирования строк при многострочном вводе;
+//   * многострочный ввод: Enter отправляет, Ctrl+J (и Shift+Enter в
+//     терминалах с расширенным протоколом) вставляют перевод строки.
+//
+// Все управляющие символы собираются из кодов, чтобы в файле не было
+// «сырых» ESC/CR/LF в строковых литералах (см. AGENTS.md).
+const NL = String.fromCharCode(10);
+const CR = String.fromCharCode(13);
+const ESC = String.fromCharCode(27);
+const PASTE_START = ESC + '[200~';
+const PASTE_END = ESC + '[201~';
+const DOTS = ['.', '..', '...'];
+const HINT = theme.dim('  ·  Enter — отправить, Ctrl+J — новая строка, Esc — стоп');
+function safeJson(v) {
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}
+// Видимая длина строки без ANSI-последовательностей.
+export function visLen(s) {
+    s = String(s);
+    let n = 0;
+    let i = 0;
+    while (i < s.length) {
+        if (s.charCodeAt(i) === 27) {
+            i++;
+            if (s[i] === '[') {
+                i++;
+                while (i < s.length && !/[A-Za-z]/.test(s[i]))
+                    i++;
+                i++;
+            }
+            continue;
+        }
+        n++;
+        i++;
+    }
+    return n;
+}
+export function layoutInput(promptStr, buf, cursor, cols) {
+    const width = Math.max(20, Number(cols) || 80);
+    const promptW = visLen(promptStr);
+    const pad = ' '.repeat(promptW);
+    const chars = Array.from(String(buf));
+    const cur = Math.max(0, Math.min(Number(cursor) || 0, chars.length));
+    const rows = [];
+    let i = 0;
+    while (true) {
+        const first = rows.length === 0;
+        const prefix = first ? promptStr : pad;
+        const avail = Math.max(1, width - promptW);
+        let text = '';
+        let count = 0;
+        const start = i;
+        while (i < chars.length && chars[i] !== NL && count < avail) {
+            text += chars[i];
+            i++;
+            count++;
+        }
+        if (i < chars.length && chars[i] === NL) {
+            i++;
+            rows.push({ prefix, text, start });
+            continue;
+        }
+        rows.push({ prefix, text, start });
+        if (i >= chars.length)
+            break;
+    }
+    let cursorRow = 0;
+    let cursorCol = promptW;
+    for (let r = 0; r < rows.length; r++) {
+        const row = rows[r];
+        const len = Array.from(row.text).length;
+        const from = row.start;
+        const to = row.start + len;
+        if (cur >= from && cur <= to) {
+            const next = rows[r + 1];
+            if (cur === to && next && next.start === to)
+                continue;
+            cursorRow = r;
+            cursorCol = promptW + (cur - from);
+            break;
+        }
+    }
+    return { rows, cursorRow, cursorCol };
+}
+export class LineEditor {
+    promptStr;
+    buf;
+    cursor;
+    statusText;
+    pendingText;
+    rendered;
+    cursorRowFromTop;
+    busy;
+    onSubmit;
+    onEscape;
+    onCtrlC;
+    _inPaste;
+    _dotTimer;
+    _dotPhase;
+    _thinkBase;
+    _wasRaw;
+    _onData;
+    constructor({ prompt = '> ' } = {}) {
+        this.promptStr = prompt;
+        this.buf = '';
+        this.cursor = 0;
+        this.statusText = '';
+        this.pendingText = null;
+        this.rendered = false;
+        this.cursorRowFromTop = 0;
+        this.busy = false;
+        this.onSubmit = null;
+        this.onEscape = null;
+        this.onCtrlC = null;
+        this._inPaste = false;
+        this._dotTimer = null;
+        this._dotPhase = 0;
+        this._thinkBase = '';
+        this._wasRaw = false;
+        this._onData = (b) => this._handle(b);
+    }
+    start() {
+        const stdin = process.stdin;
+        if (!stdin.isTTY || !stdin.setRawMode)
+            return false;
+        this._wasRaw = stdin.isRaw;
+        stdin.setRawMode(true);
+        stdin.resume();
+        process.stdout.write(ESC + '[?2004h');
+        stdin.on('data', this._onData);
+        this._writeBlock();
+        return true;
+    }
+    dispose() {
+        const stdin = process.stdin;
+        stdin.removeListener('data', this._onData);
+        process.stdout.write(ESC + '[?2004l');
+        this._stopDots();
+        if (this.rendered)
+            this._eraseBlock();
+        if (stdin.setRawMode)
+            stdin.setRawMode(this._wasRaw || false);
+    }
+    setPrompt(str) {
+        this.promptStr = str;
+        this._render();
+    }
+    clear() {
+        this.buf = '';
+        this.cursor = 0;
+        this._render();
+    }
+    // ---------- отрисовка ----------
+    _eraseBlock() {
+        if (!this.rendered)
+            return;
+        if (this.cursorRowFromTop > 0) {
+            process.stdout.write(ESC + '[' + this.cursorRowFromTop + 'A');
+        }
+        process.stdout.write(CR + ESC + '[J');
+        this.rendered = false;
+    }
+    _writeBlock() {
+        const cols = process.stdout.columns || 80;
+        let out = '';
+        let top = 0;
+        if (this.statusText) {
+            out += this.statusText + NL;
+            top = 1;
+        }
+        const lay = layoutInput(this.promptStr, this.buf, this.cursor, cols);
+        out += lay.rows.map((r) => r.prefix + r.text).join(NL);
+        process.stdout.write(out);
+        const lastRow = lay.rows.length - 1;
+        const up = lastRow - lay.cursorRow;
+        if (up > 0)
+            process.stdout.write(ESC + '[' + up + 'A');
+        process.stdout.write(CR);
+        if (lay.cursorCol > 0)
+            process.stdout.write(ESC + '[' + lay.cursorCol + 'C');
+        this.rendered = true;
+        this.cursorRowFromTop = top + lay.cursorRow;
+    }
+    _render() {
+        this._eraseBlock();
+        this._writeBlock();
+    }
+    // Напечатать блок ВЫШЕ строки ввода и вернуть строку ввода на место.
+    printAbove(text) {
+        this._eraseBlock();
+        process.stdout.write(String(text) + NL);
+        this._writeBlock();
+    }
+    // ---------- интерфейс, совместимый со спиннером ----------
+    setStatus(text) {
+        this.statusText = text || '';
+        this._render();
+    }
+    _stopDots() {
+        if (this._dotTimer) {
+            clearInterval(this._dotTimer);
+            this._dotTimer = null;
+        }
+    }
+    _startThinking() {
+        if (this.pendingText) {
+            this.setStatus(theme.prompt('✎ ') + this.pendingText + HINT);
+            return;
+        }
+        this._thinkBase = theme.brown(stripEllipsis(randomThinkingPhrase()));
+        this._dotPhase = 0;
+        this.setStatus(this._thinkBase + DOTS[0] + HINT);
+        this._stopDots();
+        this._dotTimer = setInterval(() => {
+            this._dotPhase = (this._dotPhase + 1) % DOTS.length;
+            this.setStatus(this._thinkBase + DOTS[this._dotPhase] + HINT);
+        }, 400);
+        if (this._dotTimer.unref)
+            this._dotTimer.unref();
+    }
+    thinking() {
+        this._startThinking();
+    }
+    setPending(text) {
+        this.pendingText = text && String(text).length ? String(text) : null;
+        if (this.pendingText) {
+            this._stopDots();
+            this.setStatus(theme.prompt('✎ ') + this.pendingText + HINT);
+        }
+        else {
+            this._startThinking();
+        }
+    }
+    stop() {
+        this._stopDots();
+        this.setStatus('');
+    }
+    toolCall(name, args) {
+        const preview = safeJson(args).slice(0, 120);
+        this.printAbove(theme.tool('🔧 ' + name) + ' ' + theme.dim(preview));
+    }
+    toolResult(result) {
+        const text = typeof result === 'string' ? result : safeJson(result);
+        const preview = text.slice(0, 200).split(NL).join(' ↵ ');
+        this.printAbove(theme.toolResult('   → ' + preview));
+    }
+    assistant(msg) {
+        this.stop();
+        const rendered = renderMarkdown(msg);
+        this.printAbove(NL + theme.assistant('● Ответ') + NL + rendered + NL + theme.dim('─'.repeat(60)));
+    }
+    // ---------- ввод ----------
+    _submit() {
+        const text = this.buf;
+        if (!text.trim()) {
+            this._render();
+            return;
+        }
+        this.buf = '';
+        this.cursor = 0;
+        this.pendingText = null;
+        this._stopDots();
+        this.statusText = '';
+        this.printAbove(theme.user('❯ ') + text);
+        if (this.onSubmit)
+            this.onSubmit(text);
+    }
+    _insert(text) {
+        const chars = Array.from(this.buf);
+        const ins = Array.from(String(text));
+        const next = chars.slice(0, this.cursor).concat(ins, chars.slice(this.cursor));
+        this.buf = next.join('');
+        this.cursor += ins.length;
+    }
+    _backspace() {
+        if (this.cursor <= 0)
+            return;
+        const chars = Array.from(this.buf);
+        chars.splice(this.cursor - 1, 1);
+        this.buf = chars.join('');
+        this.cursor--;
+    }
+    _delete() {
+        const chars = Array.from(this.buf);
+        if (this.cursor >= chars.length)
+            return;
+        chars.splice(this.cursor, 1);
+        this.buf = chars.join('');
+    }
+    _left() {
+        if (this.cursor > 0)
+            this.cursor--;
+    }
+    _right() {
+        if (this.cursor < Array.from(this.buf).length)
+            this.cursor++;
+    }
+    _home() {
+        const chars = Array.from(this.buf);
+        let i = this.cursor;
+        while (i > 0 && chars[i - 1] !== NL)
+            i--;
+        this.cursor = i;
+    }
+    _end() {
+        const chars = Array.from(this.buf);
+        let i = this.cursor;
+        while (i < chars.length && chars[i] !== NL)
+            i++;
+        this.cursor = i;
+    }
+    _up() {
+        const chars = Array.from(this.buf);
+        let start = this.cursor;
+        while (start > 0 && chars[start - 1] !== NL)
+            start--;
+        if (start === 0)
+            return;
+        const col = this.cursor - start;
+        const prevEnd = start - 1;
+        let prevStart = prevEnd;
+        while (prevStart > 0 && chars[prevStart - 1] !== NL)
+            prevStart--;
+        this.cursor = prevStart + Math.min(col, prevEnd - prevStart);
+    }
+    _down() {
+        const chars = Array.from(this.buf);
+        let end = this.cursor;
+        while (end < chars.length && chars[end] !== NL)
+            end++;
+        if (end >= chars.length)
+            return;
+        let lineStart = this.cursor;
+        while (lineStart > 0 && chars[lineStart - 1] !== NL)
+            lineStart--;
+        const col = this.cursor - lineStart;
+        const nextStart = end + 1;
+        let nextEnd = nextStart;
+        while (nextEnd < chars.length && chars[nextEnd] !== NL)
+            nextEnd++;
+        this.cursor = nextStart + Math.min(col, nextEnd - nextStart);
+    }
+    _handle(data) {
+        let s = data.toString('utf-8');
+        if (!this._inPaste && s === ESC) {
+            if (this.onEscape)
+                this.onEscape();
+            return;
+        }
+        while (s.length) {
+            if (this._inPaste) {
+                const end = s.indexOf(PASTE_END);
+                if (end === -1) {
+                    this._insert(s);
+                    s = '';
+                }
+                else {
+                    this._insert(s.slice(0, end));
+                    s = s.slice(end + PASTE_END.length);
+                    this._inPaste = false;
+                }
+                this._render();
+                continue;
+            }
+            const pasteAt = s.indexOf(PASTE_START);
+            if (pasteAt !== -1) {
+                const before = s.slice(0, pasteAt);
+                s = s.slice(pasteAt + PASTE_START.length);
+                this._inPaste = true;
+                if (before) {
+                    this._insert(before);
+                    this._render();
+                }
+                continue;
+            }
+            // Shift+Enter в терминалах с расширенным протоколом и Alt+Enter.
+            if (s.startsWith(ESC + '[13;2u')) {
+                this._insert(NL);
+                s = s.slice(7);
+                this._render();
+                continue;
+            }
+            if (s.startsWith(ESC + '[27;2;13~')) {
+                this._insert(NL);
+                s = s.slice(10);
+                this._render();
+                continue;
+            }
+            if (s.startsWith(ESC + NL)) {
+                this._insert(NL);
+                s = s.slice(2);
+                this._render();
+                continue;
+            }
+            const ch = s[0];
+            const code = s.charCodeAt(0);
+            s = s.slice(1);
+            if (ch === CR) {
+                this._submit();
+                continue;
+            }
+            if (code === 10) {
+                this._insert(NL);
+                this._render();
+                continue;
+            }
+            if (code === 3) {
+                if (this.onCtrlC)
+                    this.onCtrlC();
+                continue;
+            }
+            if (code === 4) {
+                if (!this.buf && this.onCtrlC)
+                    this.onCtrlC();
+                continue;
+            }
+            if (code === 1) {
+                this._home();
+                this._render();
+                continue;
+            }
+            if (code === 5) {
+                this._end();
+                this._render();
+                continue;
+            }
+            if (code === 21) {
+                this.buf = '';
+                this.cursor = 0;
+                this._render();
+                continue;
+            }
+            if (code === 127 || code === 8) {
+                this._backspace();
+                this._render();
+                continue;
+            }
+            if (code === 27) {
+                if (s.startsWith('[D')) {
+                    this._left();
+                    s = s.slice(2);
+                    this._render();
+                    continue;
+                }
+                if (s.startsWith('[C')) {
+                    this._right();
+                    s = s.slice(2);
+                    this._render();
+                    continue;
+                }
+                if (s.startsWith('[A')) {
+                    this._up();
+                    s = s.slice(2);
+                    this._render();
+                    continue;
+                }
+                if (s.startsWith('[B')) {
+                    this._down();
+                    s = s.slice(2);
+                    this._render();
+                    continue;
+                }
+                if (s.startsWith('[H') || s.startsWith('[1~')) {
+                    this._home();
+                    s = s.slice(s.startsWith('[1~') ? 3 : 2);
+                    this._render();
+                    continue;
+                }
+                if (s.startsWith('[F') || s.startsWith('[4~')) {
+                    this._end();
+                    s = s.slice(s.startsWith('[4~') ? 3 : 2);
+                    this._render();
+                    continue;
+                }
+                if (s.startsWith('[3~')) {
+                    this._delete();
+                    s = s.slice(3);
+                    this._render();
+                    continue;
+                }
+                let j = 0;
+                while (j < s.length && !/[A-Za-z~]/.test(s[j]))
+                    j++;
+                s = s.slice(j + 1);
+                continue;
+            }
+            if (code < 32)
+                continue;
+            this._insert(ch);
+            this._render();
+        }
+    }
+}
+// Проверка раскладки: node src/input.js --selftest
+export function selftest() {
+    const cases = [
+        { p: '> ', b: 'hello', c: 5, w: 80 },
+        { p: '> ', b: 'a' + NL + 'b', c: 3, w: 80 },
+        { p: '> ', b: 'x'.repeat(200), c: 200, w: 40 },
+        { p: '> ', b: '', c: 0, w: 40 },
+    ];
+    for (const t of cases) {
+        const r = layoutInput(t.p, t.b, t.c, t.w);
+        console.log(JSON.stringify({ rows: r.rows.length, row: r.cursorRow, col: r.cursorCol }));
+    }
+}
+if (process.argv[1] && process.argv[1].endsWith('input.js') && process.argv.includes('--selftest')) {
+    selftest();
+}

package/dist/markdown.js

@@ -0,0 +1,47 @@
+import { render } from 'markdansi';
+import { highlight } from 'cli-highlight';
+const theme = {
+    heading: { color: '#9fb8d8', bold: true },
+    strong: { color: '#e6e0cc', bold: true },
+    emph: { color: '#cfc9b0', italic: true },
+    inlineCode: { color: '#9ecb9e' },
+    blockCode: { color: '#c9d1c9' },
+    code: { color: '#9ecb9e' },
+    link: { color: '#8fb8d8', underline: true },
+    quote: { color: '#8a8f9a', italic: true },
+    hr: { color: '#5b616e' },
+    listMarker: { color: '#8a9bb5' },
+    tableHeader: { color: '#9fb8d8', bold: true },
+    tableCell: { color: '#d0d0d0' },
+};
+// Подсветка кода через cli-highlight (транзитивно уже есть у нас).
+function highlighter(code, lang) {
+    try {
+        return highlight(code, {
+            language: lang || 'plaintext',
+            ignoreIllegals: true,
+        });
+    }
+    catch {
+        return code;
+    }
+}
+export function renderMarkdown(text) {
+    if (!text)
+        return '';
+    try {
+        return render(String(text), {
+            width: Math.min(process.stdout.columns || 80, 100),
+            theme: theme,
+            highlighter,
+            codeBox: true,
+            tableBorder: 'unicode',
+            listIndent: 2,
+            hyperlinks: false,
+        });
+    }
+    catch {
+        return String(text);
+    }
+}
+export default renderMarkdown;

package/dist/net-capture.js

@@ -0,0 +1,100 @@
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+// Извлечение СЫРОГО текста ответа модели из сетевых данных DeepSeek.
+//
+// Зачем: чтение ответа идёт из ОТРЕНДЕРЕННОГО DOM, а рендер DeepSeek
+// искажает ответ — превращает доллар-формулы в LaTeX (символ доллара
+// теряется), нормализует переводы строк, делает автолинки. Из-за этого
+// tool-call с шаблонными строками и экранированными переводами строк в
+// аргументах доходил до инструментов искажённым. Здесь мы достаём исходный
+// текст из тела сетевого ответа.
+export function extractFromSse(body) {
+    const chunks = [];
+    const lines = body.split(String.fromCharCode(10));
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('data:'))
+            continue;
+        const payload = trimmed.slice(5).trim();
+        if (!payload || payload === '[DONE]')
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(payload);
+        }
+        catch {
+            continue;
+        }
+        const t = pickAnswerText(obj);
+        if (t)
+            chunks.push(t);
+    }
+    return chunks.join('');
+}
+export function extractFromJson(body) {
+    let obj;
+    try {
+        obj = JSON.parse(body);
+    }
+    catch {
+        return '';
+    }
+    return pickAnswerText(obj);
+}
+// Достаёт финальный текст ответа из узла, НЕ смешивая его с reasoning.
+// Порядок: choices/messages -> delta/message -> content; reasoning_content
+// намеренно не берём — это размышления модели, а не ответ.
+function pickAnswerText(node) {
+    if (node == null)
+        return '';
+    if (typeof node === 'string')
+        return node;
+    if (Array.isArray(node)) {
+        return node.map(pickAnswerText).join('');
+    }
+    if (typeof node !== 'object')
+        return '';
+    const obj = node;
+    for (const key of ['choices', 'messages']) {
+        const v = obj[key];
+        if (Array.isArray(v) && v.length) {
+            const inner = v.map(pickAnswerText).join('');
+            if (inner)
+                return inner;
+        }
+    }
+    for (const key of ['content', 'text', 'answer', 'response']) {
+        const v = obj[key];
+        if (typeof v === 'string' && v)
+            return v;
+    }
+    for (const key of ['delta', 'message', 'data', 'payload', 'v']) {
+        const v = obj[key];
+        if (v && typeof v === 'object') {
+            const inner = pickAnswerText(v);
+            if (inner)
+                return inner;
+        }
+    }
+    return '';
+}
+// Универсальная попытка: сначала SSE, затем обычный JSON.
+export function extractAnswer(body) {
+    const sse = extractFromSse(body);
+    if (sse)
+        return sse;
+    return extractFromJson(body);
+}
+// Сохраняет тело сетевого ответа DeepSeek на диск для разбора постфактум.
+// Файлы лежат в ~/.zames/net-log — по ним видно реальный формат ответа.
+export async function dumpNetBody(url, body) {
+    try {
+        const dir = path.join(os.homedir(), '.zames', 'net-log');
+        await fs.mkdir(dir, { recursive: true });
+        const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const safe = url.replace(/[^a-zA-Z0-9_.-]/g, '_').slice(0, 80);
+        await fs.writeFile(path.join(dir, stamp + '_' + safe + '.txt'), body, 'utf-8');
+    }
+    catch { }
+}