zames_pro 1.1.0 → 1.2.0

package/src/index.js

@@ -2,13 +2,13 @@
 import path from 'path'
 import fs from 'fs/promises'
 import { fileURLToPath } from 'url'
-import * as readlinePromises from 'readline/promises'
 import { theme } from './theme.js'
 
 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 { loadConfig, CONFIG_PATHS, ZAMES_HOME } from './config.js'
 import { Transcript } from './transcript.js'
 import { UndoStore } from './undo.js'
@@ -201,6 +201,10 @@ ${theme.bold('Опции CLI:')}
   --version, -v      показать версию
   --help, -h         эта справка
 
+${theme.bold('Пока агент работает:')}
+  печать + Enter           поставить сообщение в очередь (уйдёт после текущей задачи)
+  Esc, Ctrl+C              прервать текущую генерацию
+
 ${theme.bold('Обычные команды:')}
   /new, /clear             новый чат (сброс контекста)
   /chats                   список последних чатов DeepSeek
@@ -256,46 +260,352 @@ async function cleanTmpDir() {
   }
 }
 
+// Ввод строки в терминале с корректной обработкой вставки (Shift+Insert,
+// Ctrl+Shift+V, правая кнопка мыши и т.п.).
+//
+// Зачем свой ридер вместо readline:
+//   1) readline отправляет строку на ПЕРВОМ переводе строки. При вставке
+//      многострочного текста это приводило к немедленной отправке и к тому,
+//      что в чат уходила только первая строка. Здесь переводы строк внутри
+//      вставки заменяются на пробелы, а отправка происходит только по
+//      одиночному нажатию Enter.
+//   2) Включаем bracketed paste mode (\x1b[?2004h): терминал оборачивает
+//      вставленный текст в маркеры \x1b[200~ … \x1b[201~, поэтому мы точно
+//      знаем, что это вставка, а не набор с клавиатуры, и Enter внутри неё
+//      не считается отправкой.
 async function promptOnce(question) {
-  process.stdin.resume()
-  if (process.stdin.isTTY && process.stdin.setRawMode) {
-    process.stdin.setRawMode(false)
+  const stdin = process.stdin
+  const stdout = process.stdout
+
+  // Не-TTY (пайп, редирект): читаем всё до EOF одной строкой.
+  if (!stdin.isTTY || !stdin.setRawMode) {
+    const chunks = []
+    return await new Promise((resolve) => {
+      const onData = (b) => chunks.push(b)
+      const onEnd = () => {
+        stdin.removeListener('data', onData)
+        stdin.removeListener('end', onEnd)
+        resolve(Buffer.concat(chunks).toString('utf-8'))
+      }
+      stdin.on('data', onData)
+      stdin.on('end', onEnd)
+      stdin.resume()
+    })
   }
-  const rl = readlinePromises.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  })
-  try {
-    return await rl.question(question)
-  } finally {
-    rl.close()
+
+  const wasRaw = stdin.isRaw
+  stdin.setRawMode(true)
+  stdin.resume()
+
+  // Bracketed paste включаем/выключаем парно.
+  stdout.write('\x1b[?2004h')
+  stdout.write(question)
+
+  let line = ''
+  let cursor = 0
+  let inPaste = false
+  const PASTE_START = '\x1b[200~'
+  const PASTE_END = '\x1b[201~'
+
+  const redraw = () => {
+    // Возвращаемся в начало строки, стираем и печатаем заново.
+    stdout.write(String.fromCharCode(13))
+    stdout.write('\x1b[K')
+    stdout.write(question + line)
+    // Ставим курсор в нужную позицию.
+    const back = line.length - cursor
+    if (back > 0) stdout.write('\x1b[' + back + 'D')
   }
+
+  return await new Promise((resolve) => {
+    const finish = (value, submit) => {
+      stdin.removeListener('data', onData)
+      stdout.write('\x1b[?2004l')
+      if (stdin.setRawMode) stdin.setRawMode(wasRaw || false)
+      if (submit) stdout.write(String.fromCharCode(10))
+      resolve(value)
+    }
+
+    const insertText = (text) => {
+      // Нормализуем переводы строк: они приходят от многострочной вставки,
+      // но означают «отправить». Внутри сообщения заменяем на пробел, чтобы
+      // вся вставка ушла ОДНИМ сообщением.
+      const clean = text
+        .replace(/\r\n/g, ' ')
+        .replace(/\r/g, ' ')
+        .replace(/\n/g, ' ')
+      line = line.slice(0, cursor) + clean + line.slice(cursor)
+      cursor += clean.length
+    }
+
+    const onData = (buf) => {
+      let s = buf.toString('utf-8')
+
+      // Fallback для терминалов без bracketed paste: если весь чанк — это
+      // «голый» перевод строки (один байт), значит нажали Enter → отправляем.
+      // Если переводы строк пришли ВМЕСТЕ с другим текстом в одном чанке —
+      // это вставка; такие переводы строк не отправляют сообщение, а
+      // заменяются на пробелы (см. insertText).
+      if (!inPaste && (s === '\r' || s === '\n')) {
+        return finish(line, true)
+      }
+
+      while (s.length) {
+        if (inPaste) {
+          const end = s.indexOf(PASTE_END)
+          if (end === -1) {
+            insertText(s)
+            s = ''
+          } else {
+            insertText(s.slice(0, end))
+            s = s.slice(end + PASTE_END.length)
+            inPaste = false
+          }
+          redraw()
+          continue
+        }
+
+        const start = s.indexOf(PASTE_START)
+        if (start !== -1) {
+          // Всё до маркера обрабатываем как обычный ввод.
+          const before = s.slice(0, start)
+          s = s.slice(start + PASTE_START.length)
+          inPaste = true
+          if (before) {
+            for (const ch of before) {
+              if (ch === '\r' || ch === '\n') { /* внутри вставки — пропускаем */ }
+              else insertText(ch)
+            }
+            redraw()
+          }
+          continue
+        }
+
+        const ch = s[0]
+        const code = s.charCodeAt(0)
+        s = s.slice(1)
+
+        if (ch === '\r' || ch === '\n') {
+          // Перевод строки внутри чанка с другим текстом (вставка без
+          // bracketed paste): не отправляем, а вставляем пробел.
+          insertText(' ')
+          redraw()
+          continue
+        }
+        if (code === 3) {
+          // Ctrl+C — прерываем ввод.
+          return finish('', true)
+        }
+        if (code === 4) {
+          // Ctrl+D — как отправка пустой строки.
+          return finish(line, true)
+        }
+        if (code === 21) {
+          // Ctrl+U — стереть строку.
+          line = ''
+          cursor = 0
+          redraw()
+          continue
+        }
+        if (code === 127 || code === 8) {
+          // Backspace.
+          if (cursor > 0) {
+            line = line.slice(0, cursor - 1) + line.slice(cursor)
+            cursor--
+            redraw()
+          }
+          continue
+        }
+        if (ch === '\x1b') {
+          // Escape-последовательности (стрелки, Home/End, Delete…).
+          const rest = s
+          if (rest.startsWith('[D')) {
+            if (cursor > 0) cursor--
+            s = s.slice(2)
+            redraw()
+            continue
+          }
+          if (rest.startsWith('[C')) {
+            if (cursor < line.length) cursor++
+            s = s.slice(2)
+            redraw()
+            continue
+          }
+          if (rest.startsWith('[H') || rest.startsWith('[1~')) {
+            cursor = 0
+            s = s.slice(rest.startsWith('[1~') ? 3 : 2)
+            redraw()
+            continue
+          }
+          if (rest.startsWith('[F') || rest.startsWith('[4~')) {
+            cursor = line.length
+            s = s.slice(rest.startsWith('[4~') ? 3 : 2)
+            redraw()
+            continue
+          }
+          if (rest.startsWith('[3~')) {
+            // Delete.
+            if (cursor < line.length) {
+              line = line.slice(0, cursor) + line.slice(cursor + 1)
+              redraw()
+            }
+            s = s.slice(3)
+            continue
+          }
+          // Прочие ESC-последовательности пропускаем до буквы/тильды.
+          const m = s.match(/^\[[0-9;]*[A-Za-z~]/)
+          if (m) s = s.slice(m[0].length)
+          continue
+        }
+        if (code < 32) continue // прочие управляющие символы игнорируем
+
+        insertText(ch)
+        redraw()
+      }
+    }
+
+    stdin.on('data', onData)
+  })
 }
 
 // Слежение за клавиатурой во время работы агента.
-// Esc — прервать текущую генерацию (клик Stop в браузере).
-function watchEscape(onEscape) {
+//
+// Терминал остаётся живым, пока агент думает:
+//   - Esc (или Ctrl+C) — прервать текущую генерацию (клик Stop в браузере);
+//   - набор текста + Enter — поставить сообщение в очередь; оно уйдёт
+//     агенту сразу после того, как текущая задача завершится
+//     (как «отправить во время генерации» в веб-версии DeepSeek).
+//
+// Ввод буферизуется без построчного редактора: набранный текст отображается
+// в строке спиннера через onChange -> ui.setPending(). Enter отправляет буфер
+// в onQueue, пустой Enter игнорируется. Поддержаны Backspace, Ctrl+U, Esc-
+// последовательности (стрелки/Home/End/Delete игнорируются) и bracketed paste.
+function watchInput({ onEscape, onChange, onQueue } = {}) {
   const stdin = process.stdin
-  if (!stdin.isTTY) return () => {}
+  if (!stdin.isTTY || !stdin.setRawMode) return () => {}
+
+  // Управляющие символы собираем из кодов: в этом файле нельзя писать
+  // «сырые» ESC/CR/LF в строковых литералах (см. AGENTS.md).
+  const ESC = String.fromCharCode(27)
+  const CSI = String.fromCharCode(91)
+  const CR = String.fromCharCode(13)
+  const LF = String.fromCharCode(10)
+
   const wasRaw = stdin.isRaw
-  if (stdin.setRawMode) stdin.setRawMode(true)
+  stdin.setRawMode(true)
   stdin.resume()
-  const handler = (buf) => {
-    if (buf.length === 1 && buf[0] === 27) {
-      onEscape()
+  process.stdout.write(ESC + '[?2004h')
+
+  let buf = ''
+  let inPaste = false
+  const PASTE_START = ESC + '[200~'
+  const PASTE_END = ESC + '[201~'
+  const CSI_RE = new RegExp('^' + CSI + '[0-9;]*[A-Za-z~]')
+
+  const emitChange = () => {
+    if (onChange) onChange(buf)
+  }
+
+  // Вставленный текст: переводы строк внутри многострочной вставки
+  // трактуем как пробелы — сообщение уходит одной строкой.
+  const insert = (text) => {
+    buf += text
+      .split(CR + LF).join(' ')
+      .split(CR).join(' ')
+      .split(LF).join(' ')
+  }
+
+  function onData(data) {
+    let s = data.toString('utf-8')
+
+    // Одиночный Esc — прервать генерацию. Стрелки приходят целым чанком
+    // и сюда не попадают.
+    if (!inPaste && s === ESC) {
+      if (onEscape) onEscape()
+      return
+    }
+
+    while (s.length) {
+      if (inPaste) {
+        const end = s.indexOf(PASTE_END)
+        if (end === -1) {
+          insert(s)
+          s = ''
+        } else {
+          insert(s.slice(0, end))
+          s = s.slice(end + PASTE_END.length)
+          inPaste = false
+        }
+        emitChange()
+        continue
+      }
+
+      const start = s.indexOf(PASTE_START)
+      if (start !== -1) {
+        const before = s.slice(0, start)
+        s = s.slice(start + PASTE_START.length)
+        inPaste = true
+        if (before) {
+          insert(before)
+          emitChange()
+        }
+        continue
+      }
+
+      const ch = s[0]
+      const code = s.charCodeAt(0)
+      s = s.slice(1)
+
+      if (ch === CR || ch === LF) {
+        const text = buf.trim()
+        buf = ''
+        emitChange()
+        if (text && onQueue) onQueue(text)
+        continue
+      }
+      if (code === 3) {
+        // Ctrl+C — как Esc: прервать генерацию.
+        if (onEscape) onEscape()
+        continue
+      }
+      if (code === 21) {
+        // Ctrl+U — очистить набранное.
+        buf = ''
+        emitChange()
+        continue
+      }
+      if (code === 127 || code === 8) {
+        // Backspace.
+        if (buf) {
+          buf = buf.slice(0, -1)
+          emitChange()
+        }
+        continue
+      }
+      if (ch === ESC) {
+        // Escape-последовательность (стрелки, Home/End, Delete) — пропускаем.
+        const m = s.match(CSI_RE)
+        if (m) s = s.slice(m[0].length)
+        continue
+      }
+      if (code < 32) continue // прочие управляющие — игнорируем
+
+      buf += ch
+      emitChange()
     }
   }
+
+  const handler = (data) => onData(data)
   stdin.on('data', handler)
   return () => {
     stdin.removeListener('data', handler)
+    process.stdout.write(ESC + '[?2004l')
     if (stdin.setRawMode) stdin.setRawMode(wasRaw || false)
   }
 }
 
 // ---------- workdir resolution ----------
 
-// ---------- workdir resolution ----------
-
 // Агент работает в директории, из которой его запустили (process.cwd()).
 // Это корень sandbox: инструменты не могут выходить выше него.
 async function resolveWorkdir() {
@@ -311,47 +621,75 @@ async function resolveWorkdir() {
 // ---------- task runner ----------
 
 async function runTask(browser, tools, taskText, workdir, opts) {
-  const { transcript, freshChat, sendSystemPrompt } = opts
-
-  const ui = mod.createSpinner()
-  ui.thinking()
-
-  // Esc во время работы — прервать генерацию.
-  const stopWatching = watchEscape(() => {
-    ui.stop()
-    console.error(theme.warn('⏹ Esc — прерываю генерацию...'))
-    browser.stopGeneration().catch(() => {})
-  })
-
-  let finished = false
+  const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor } = opts
+
+  // В TTY-режиме UI — это LineEditor: он владеет вводом (очередь, Esc,
+  // Ctrl+C) и рисует статус НАД постоянной строкой ввода. В не-TTY режиме
+  // (пайпы) — обычный спиннер + watchInput.
+  const ui = editor || mod.createSpinner()
+  const stopWatching = editor
+    ? () => {}
+    : watchInput({
+        onEscape: () => {
+          ui.stop()
+          console.error(theme.warn('⏹ Esc — прерываю генерацию...'))
+          browser.stopGeneration().catch(() => {})
+        },
+        onChange: (text) => ui.setPending(text),
+        onQueue: (text) => {
+          queue.push(text)
+          ui.setPending(null)
+          ui.stop()
+          console.log(
+            theme.user('📨 В очередь (' + queue.length + '): ') + theme.assistant(text),
+          )
+          ui.thinking()
+        },
+      })
 
   try {
-    await mod.runAgentLoop({
-      browser,
-      tools,
-      task: taskText,
-      workdir,
-      maxIterations: maxIter,
-      freshChat,
-      sendSystemPrompt,
-      transcript,
-      onThinking: () => ui.thinking(),
-      onToolCall: (name, toolArgs) => ui.toolCall(name, toolArgs),
-      onToolResult: (result) => ui.toolResult(result),
-      onAssistantMessage: (msg) => {
-        ui.assistant(msg)
-        finished = true
-      },
-      debugLog: debug,
-    })
+    let next = { task: taskText, freshChat, sendSystemPrompt }
+
+    // Выполняем задачу, затем — всё, что пользователь успел напечатать за
+    // время работы. Очередь может пополняться прямо во время дренажа.
+    while (true) {
+      ui.thinking()
+      await mod.runAgentLoop({
+        browser,
+        tools,
+        task: next.task,
+        workdir,
+        maxIterations: maxIter,
+        freshChat: next.freshChat,
+        sendSystemPrompt: next.sendSystemPrompt,
+        transcript,
+        onThinking: () => ui.thinking(),
+        onToolCall: (name, toolArgs) => ui.toolCall(name, toolArgs),
+        onToolResult: (result) => ui.toolResult(result),
+        onAssistantMessage: (msg) => ui.assistant(msg),
+        debugLog: debug,
+      })
+
+      if (!queue.length) break
+
+      const queued = queue.shift()
+      ui.stop()
+      if (editor) {
+        editor.printAbove(theme.user('▶ Из очереди: ') + theme.assistant(queued))
+      } else {
+        console.log(theme.user('▶ Из очереди: ') + theme.assistant(queued))
+      }
+      transcript?.log('queued_task', { task: queued })
+      next = { task: queued, freshChat: false, sendSystemPrompt: false }
+    }
   } catch (e) {
     ui.stop()
-    console.error(theme.error('\n✖ Ошибка агента:'), e.message)
+    console.error(theme.error(String.fromCharCode(10) + '✖ Ошибка агента:'), e.message)
     if (debug) console.error(e.stack)
     transcript?.log('agent_error', { error: e.message })
   } finally {
     stopWatching()
-    if (!finished) ui.stop()
+    ui.stop()
   }
 }
 
@@ -468,7 +806,12 @@ async function main() {
 
   console.log(
     theme.system(
-      'Интерактивный режим. Введите задачу. Команды — /help. Выход — /exit.\n',
+      'Интерактивный режим. Введите задачу. Команды — /help. Выход — /exit.',
+    ),
+  )
+  console.log(
+    theme.system(
+      'Пока агент работает, можно печатать следующее сообщение — оно уйдёт в очередь (Enter — отправить, Esc — прервать).',
     ),
   )
 
@@ -478,6 +821,10 @@ async function main() {
   let currentChatId = null
   let running = true
 
+  // Сообщения, набранные пользователем, пока агент работал. runTask
+  // забирает их по одному после завершения текущей задачи.
+  const pendingQueue = []
+
   // ---------- review mode state ----------
   // null — обычный режим.
   // { snapDir, snapName, originalWorkdir } — мы внутри снапшота, чат уже
@@ -518,18 +865,98 @@ async function main() {
     }
   }
 
+  // ---------- ввод: постоянная строка внизу + статус сверху ----------
+  // В TTY используем LineEditor: он владеет вводом всё время, показывает
+  // статус над строкой ввода и печатает ответы агента ВЫШЕ неё, поэтому
+  // набранный текст никогда не затирается выводом. В не-TTY (пайп) —
+  // старый promptOnce.
+  let editor = null
+  let waiter = null
+  const takeInput = () => {
+    if (pendingQueue.length) return Promise.resolve(pendingQueue.shift())
+    return new Promise((resolve) => {
+      waiter = resolve
+    })
+  }
+
+  const buildPrompt = () => {
+    let tail
+    if (reviewMode) {
+      tail = theme.warn('REVIEW') + theme.dim(':') + theme.dir(reviewMode.snapName)
+    } else {
+      tail = theme.dir(dirLabel(currentWorkdir))
+    }
+    return theme.prompt('❯ ') + tail + theme.dim(' › ')
+  }
+
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    editor = new LineEditor({ prompt: buildPrompt() })
+    editor.onSubmit = (text) => {
+      pendingQueue.push(text)
+      if (waiter) {
+        const r = waiter
+        waiter = null
+        r(pendingQueue.shift())
+      }
+    }
+    editor.onEscape = () => {
+      if (editor.busy) {
+        editor.printAbove(theme.warn('⏹ Esc — прерываю генерацию...'))
+        browser.stopGeneration().catch(() => {})
+      }
+    }
+    editor.onCtrlC = () => {
+      if (editor.busy) {
+        editor.printAbove(theme.warn('⏹ Ctrl+C — прерываю генерацию...'))
+        browser.stopGeneration().catch(() => {})
+      } else {
+        // Не заняты — выходим. Будим takeInput(), чтобы цикл завершился.
+        running = false
+        if (waiter) {
+          const r = waiter
+          waiter = null
+          r(null)
+        }
+      }
+    }
+    editor.start()
+
+    // Весь вывод команд (console.log/error) должен идти ВЫШЕ строки ввода,
+    // иначе он затирает набираемый текст. Пока редактор активен, заворачиваем
+    // оба потока в editor.printAbove.
+    const origLog = console.log.bind(console)
+    const origErr = console.error.bind(console)
+    const fmt = (a) =>
+      typeof a === 'string' ? a : (() => {
+        try {
+          return JSON.stringify(a)
+        } catch {
+          return String(a)
+        }
+      })()
+    console.log = (...a) => editor.printAbove(a.map(fmt).join(' '))
+    console.error = (...a) => editor.printAbove(a.map(fmt).join(' '))
+    // Сохраняем на случай отладки.
+    editor._origLog = origLog
+    editor._origErr = origErr
+  }
+
   while (running) {
     let input
     try {
-      // Компактное приглашение: золотая стрелка + светло-голубая директория.
-      let tail
-      if (reviewMode) {
-        tail =
-          theme.warn('REVIEW') + theme.dim(':') + theme.dir(reviewMode.snapName)
+      if (editor) {
+        editor.setPrompt(buildPrompt())
+        input = await takeInput()
       } else {
-        tail = theme.dir(dirLabel(currentWorkdir))
+        let tail
+        if (reviewMode) {
+          tail =
+            theme.warn('REVIEW') + theme.dim(':') + theme.dir(reviewMode.snapName)
+        } else {
+          tail = theme.dir(dirLabel(currentWorkdir))
+        }
+        input = await promptOnce(theme.prompt('❯ ') + tail + theme.dim(' › '))
       }
-      input = await promptOnce(theme.prompt('❯ ') + tail + theme.dim(' › '))
     } catch {
       break
     }
@@ -661,10 +1088,6 @@ async function main() {
             sendSystemPrompt: false,
             transcript,
             onThinking: () => ui.thinking(),
-            onAssistantThought: (text) => {
-              ui.stop()
-              console.log(theme.system('\n💭 ' + text.slice(0, 1200) + '\n'))
-            },
             onToolCall: (name, toolArgs) => ui.toolCall(name, toolArgs),
             onToolResult: (r) => ui.toolResult(r),
             onAssistantMessage: (m) => {
@@ -752,7 +1175,7 @@ async function main() {
     // ---------- Обычные команды ----------
 
     if (lower === '/chats') {
-      const spin = mod.createSpinner()
+      const spin = editor || mod.createSpinner()
       spin.thinking()
       try {
         lastChats = await browser.listChats(30)
@@ -1004,11 +1427,18 @@ async function main() {
     transcript.log('user_task', { task: trimmed, workdir: currentWorkdir })
 
     const tools = mod.createTools(currentWorkdir, { undo })
-    await runTask(browser, tools, trimmed, currentWorkdir, {
-      transcript,
-      freshChat: freshChatNext,
-      sendSystemPrompt: sendSystemPromptNext,
-    })
+    if (editor) editor.busy = true
+    try {
+      await runTask(browser, tools, trimmed, currentWorkdir, {
+        transcript,
+        freshChat: freshChatNext,
+        sendSystemPrompt: sendSystemPromptNext,
+        queue: pendingQueue,
+        ui: editor || null,
+      })
+    } finally {
+      if (editor) editor.busy = false
+    }
 
     freshChatNext = false
     sendSystemPromptNext = false
@@ -1018,6 +1448,7 @@ async function main() {
     await saveLastChat(currentChatId)
   }
 
+  if (editor) editor.dispose()
   await browser.close().catch(() => {})
   await mod.closeWeb().catch(() => {})
   transcript.close()