zames_pro 1.1.0 → 1.2.0

package/src/input.js

@@ -0,0 +1,447 @@
+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 {
+  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/src/spinner.js

@@ -2,8 +2,56 @@ import ora from 'ora'
 import { theme } from './theme.js'
 import { renderMarkdown } from './markdown.js'
 
+// Фразы для спиннера «агент работает». Выбираются в случайном порядке.
+const THINKING_PHRASES = [
+  'Замешиваю кал…',
+  'Взбиваю кал до однородной массы…',
+  'Мешаю кал с логикой…',
+  'Взбалтываю кал в коктейль…',
+  'Кручу венчиком по калу…',
+  'Смешиваю кал с кофеином…',
+  'Замешиваю тесто из кала…',
+  'Взбиваю пену из кала…',
+  'Перемешиваю кал лопатой…',
+  'Замешиваю глину из кала…',
+  'Гомогенизирую кал до состояния бетона…',
+  'Взбалтываю кал до просветления…',
+  'Блендерю кал в смузи…',
+  'Замешиваю цемент из кала…',
+  'Взбиваю кашу из кала…',
+  'Мешаю кал с надеждой…',
+  'Взбалтываю осадок из кала…',
+  'Кручу блендером по калу…',
+  'Смешиваю кал до неразличимости…',
+  'Замешиваю раствор из кала…',
+  'Взбиваю коктейль «кал»…',
+  'Перемешиваю кал лопатой дедлайна…',
+  'Замешиваю кашу из кала…',
+  'Взбиваю пенку из кала…',
+  'Гомогенизирую кал до однородности…',
+  'Взбалтываю кал в бетономешалке…',
+  'Замешиваю кал в тесто…',
+  'Сбиваю кал в однородную массу…',
+  'Размешиваю кал до просветления…',
+  'Замешиваю кал из всего подряд…',
+]
+
+export function randomThinkingPhrase() {
+  return THINKING_PHRASES[Math.floor(Math.random() * THINKING_PHRASES.length)]
+}
+
+// Убираем завершающее многоточие из фразы — точки анимируем отдельно.
+export function stripEllipsis(phrase) {
+  return phrase.replace(/[.…]+\s*$/, '')
+}
+
 export function createSpinner() {
   let spinner = null
+  let dotTimer = null
+  let dotPhase = 0
+  let pending = null
+
+  const DOTS = ['.', '..', '...']
 
   const start = (text) => {
     if (!spinner) spinner = ora(text).start()
@@ -11,11 +59,59 @@ export function createSpinner() {
   }
 
   const stop = () => {
+    if (dotTimer) {
+      clearInterval(dotTimer)
+      dotTimer = null
+    }
     if (spinner) spinner.stop()
   }
 
+  // Подсказка в строке статуса: во время работы агента терминал живой,
+  // можно печатать следующее сообщение. Без неё это неочевидно.
+  const HINT = theme.dim('  ·  печатай — Enter в очередь, Esc стоп')
+
+  // Запуск анимированного статуса: коричневый текст + «бегущие» точки.
+  const startThinking = () => {
+    const base = theme.brown(stripEllipsis(randomThinkingPhrase()))
+    start(base + DOTS[0] + HINT)
+    dotPhase = 0
+    if (dotTimer) clearInterval(dotTimer)
+    dotTimer = setInterval(() => {
+      if (!spinner) return
+      dotPhase = (dotPhase + 1) % DOTS.length
+      spinner.text = base + DOTS[dotPhase] + HINT
+    }, 400)
+    if (dotTimer.unref) dotTimer.unref()
+  }
+
+  // Показать набранный, но ещё не отправленный текст вместо спиннера.
+  // Позволяет печатать сообщение прямо во время работы агента.
+  const showPending = () => {
+    if (dotTimer) {
+      clearInterval(dotTimer)
+      dotTimer = null
+    }
+    if (!spinner) spinner = ora('')
+    spinner.start()
+    spinner.text = theme.prompt('✎ ') + pending + HINT
+  }
+
   return {
-    thinking: () => start(theme.system('Думаю...')),
+    thinking: () => {
+      if (pending) {
+        showPending()
+        return
+      }
+      startThinking()
+    },
+
+    // Текст, который пользователь набирает во время работы агента.
+    // Пустая строка / null — вернуть обычный спиннер.
+    setPending: (text) => {
+      pending = text && String(text).length ? String(text) : null
+      if (pending) showPending()
+      else startThinking()
+    },
 
     toolCall: (name, args) => {
       stop()

package/src/system-prompt.js

@@ -14,6 +14,34 @@ export function buildSystemPrompt({ workdir, tools, gitContext = null }) {
 
 You work in the directory: ${workdir}
 
+## SILENT OPERATION (most important rule)
+
+Work silently. While you are still solving the task you must output ONLY
+tool calls — nothing else. Do NOT narrate what you are about to do, do NOT
+summarize what you just did, do NOT think out loud, do NOT print progress
+like "Now I will read the file...". Every extra sentence pollutes the chat
+and the context, so keep it to zero.
+
+The operator does NOT read free text in the chat. Anything written outside a
+tool call is lost: the operator only sees tool calls and their results. In
+particular, the operator reads EXACTLY ONE thing from you — the message of the
+LAST respond tool call before you stop. Everything else is ignored.
+
+Therefore the only way to talk to the operator is the respond tool, and it
+must be your LAST action. Call respond in exactly two situations:
+  1. The task is done — report the result.
+  2. You cannot continue and must ask the operator a question or a decision.
+
+Never call respond in the middle, and never split a report across several
+messages: put the complete operator-facing text into that single final
+respond. Do NOT end a turn with plain text, and do NOT rely on plain text to
+ask or answer anything — if you have something to say, say it via respond and
+stop. If you are still working, emit a tool call instead.
+
+So the pattern is: tool call, tool call, tool call, ..., then a single final
+respond. A bare text message without a tool call ends the task and the
+operator will not read it, so never use plain text.\n\nNO PROSE AROUND TOOL CALLS. Each turn must contain ONLY the JSON of the tool\ncall(s) — not a single word before or after, not even a short lead-in like\n"Let me check..." or "Now I'll fix it.". The JSON must be the entire response.\n\nWRONG: "Let me read the file first." then a Read call.\nWRONG: a Read call then "I'll analyze the result next."\nRIGHT: only the JSON of the tool call, nothing else.\n\nIf you feel the urge to explain, do not: put it in the final respond when the\ntask is done (or when you must ask the operator), not between tool calls.
+
 You have access to the following tools:
 
 ${toolDescriptions}
@@ -28,7 +56,9 @@ To call MULTIPLE tools at once (only if they are independent — e.g. reading se
 
 [{"tool": "Read", "args": {"path": "a.js"}}, {"tool": "Read", "args": {"path": "b.js"}}]
 
-After the tool result(s) come back, decide the next action.
+After the tool result(s) come back, decide the next action and immediately
+emit the next tool call as bare JSON. Do NOT write a sentence about what
+you learned or what you will do next — no commentary between tool calls.
 
 To give a final answer to the user, respond with:
 
@@ -68,9 +98,9 @@ Inside that string:
 - Do NOT write any text before or after the JSON. No explanations, no greetings, no plans.
 - Do NOT wrap JSON in markdown fences.
 - Do NOT use XML-like tags such as tool_calls, invoke, parameter, or their DSML variants.
-- If you want to tell the user something, call the respond tool with a message.
-- If JSON parsing fails, the tool call will NOT run and the user will see raw text. Keep JSON valid: escape every double quote inside strings, escape backslashes, use 
- for newlines.
+- The ONLY way to reach the operator is the respond tool, as your LAST action.
+  Any other text is not read by the operator.
+- If JSON parsing fails, the tool call will NOT run and the user will see raw text. Keep JSON valid: escape every double quote inside strings, escape backslashes, use \n for newlines.
 
 ## Rules
 
@@ -82,7 +112,11 @@ Inside that string:
 - Never output anything except JSON when you want to call a tool.
 - Your ENTIRE response must be exactly one JSON object (or array of objects).
 
-REMINDER: respond with exactly one JSON object or array. No text, no markdown, no explanations.
+REMINDER: every intermediate response is exactly one JSON object or array —
+no text, no markdown, no explanations, no progress narration. Keep working
+with tool calls only. Talk to the operator with a single final respond call:
+when the task is done, or when you are blocked and must ask the operator.
+Anything you write outside that one respond is not read by the operator.
 ## Web access
 
 - You have WebSearch and WebFetch. Use them when the answer requires current information (versions, changelogs, recent bugs, docs).

package/src/theme.js

@@ -28,6 +28,7 @@ export const theme = {
   warn: chalk.hex('#c9a86a'), // спокойный охра
   error: chalk.hex('#c98a80'), // приглушённый терракот
   success: chalk.hex('#a9c08c'), // мягкий шалфейный
+  brown: chalk.hex('#a1723f'), // коричневый (статус/спиннер)
   bold: chalk.bold,
 }