zames_pro 1.1.1 → 1.2.1

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/sessions.js

@@ -0,0 +1,110 @@
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+
+// Сессии (чаты DeepSeek) храним в отдельной папке, чтобы они не терялись
+// после перезапуска процесса. Каждая сессия — отдельный JSON-файл
+// <id>.json в ~/.zames/.sessions. last.json указывает на последнюю
+// открытую сессию для конкретной рабочей директории.
+const SESSIONS_DIR = path.join(os.homedir(), '.zames', '.sessions')
+const INDEX_FILE = path.join(SESSIONS_DIR, 'last.json')
+
+function ensureDir() {
+  fs.mkdirSync(SESSIONS_DIR, { recursive: true })
+}
+
+function safeName(id) {
+  return String(id).replace(/[^a-zA-Z0-9_.-]/g, '_')
+}
+
+// Сохраняем/обновляем сессию. workdir нужен, чтобы при запуске из того же
+// проекта восстанавливать именно его последний чат.
+export function saveSession({ id, title = '', workdir = '' }) {
+  if (!id) return
+  try {
+    ensureDir()
+    const file = path.join(SESSIONS_DIR, safeName(id) + '.json')
+    let prev = {}
+    try { prev = JSON.parse(fs.readFileSync(file, 'utf-8')) } catch {}
+    const now = new Date().toISOString()
+    const data = {
+      id,
+      title: title || prev.title || '',
+      workdir: workdir || prev.workdir || '',
+      createdAt: prev.createdAt || now,
+      updatedAt: now,
+    }
+    fs.writeFileSync(file, JSON.stringify(data, null, 2), 'utf-8')
+    writeIndex({ id, workdir: data.workdir })
+    return data
+  } catch {
+    return null
+  }
+}
+
+function writeIndex({ id, workdir }) {
+  try {
+    ensureDir()
+    let index = {}
+    try { index = JSON.parse(fs.readFileSync(INDEX_FILE, 'utf-8')) } catch {}
+    if (!index || typeof index !== 'object') index = {}
+    if (!index.byWorkdir || typeof index.byWorkdir !== 'object') index.byWorkdir = {}
+    const key = workdir || ''
+    index.byWorkdir[key] = id
+    index.last = id
+    index.updatedAt = new Date().toISOString()
+    fs.writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2), 'utf-8')
+  } catch {}
+}
+
+// Последняя сессия для рабочей директории. Если для неё ничего нет —
+// возвращаем последнюю сессию вообще (полезно при запуске из нового места).
+export function loadLastSession(workdir = '') {
+  try {
+    const index = JSON.parse(fs.readFileSync(INDEX_FILE, 'utf-8'))
+    const byWorkdir = index && index.byWorkdir ? index.byWorkdir : {}
+    const candidates = [byWorkdir[workdir], index.last].filter(Boolean)
+    for (const id of candidates) {
+      // Файл сессии мог быть удалён — индекс тогда устарел, и сессию
+      // восстанавливать нельзя. Пробуем следующий кандидат.
+      const s = readSession(id)
+      if (s) return s
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+export function readSession(id) {
+  if (!id) return null
+  try {
+    const file = path.join(SESSIONS_DIR, safeName(id) + '.json')
+    return JSON.parse(fs.readFileSync(file, 'utf-8'))
+  } catch {
+    return null
+  }
+}
+
+// Список всех сессий, свежие — первыми.
+export function listSessions() {
+  try {
+    ensureDir()
+    const files = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith('.json') && f !== 'last.json')
+    const out = []
+    for (const f of files) {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, f), 'utf-8'))
+        if (data && data.id) out.push(data)
+      } catch {}
+    }
+    out.sort((a, b) => String(b.updatedAt || '').localeCompare(String(a.updatedAt || '')))
+    return out
+  } catch {
+    return []
+  }
+}
+
+export function sessionsDir() {
+  return SESSIONS_DIR
+}

package/src/spinner.js

@@ -36,12 +36,22 @@ const THINKING_PHRASES = [
   'Замешиваю кал из всего подряд…',
 ]
 
-function randomThinkingPhrase() {
+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()
@@ -49,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(randomThinkingPhrase())),
+    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()