zames_pro 1.2.1 → 2.1.0

package/src/tools.js

@@ -1,206 +0,0 @@
-import fs from 'fs/promises'
-import path from 'path'
-import { exec } from 'child_process'
-import { createGitTools } from './gitTools.js'
-import { createWebTools } from './web.js'
-
-export function createTools(workdir, { undo } = {}) {
-  const root = path.resolve(workdir)
-  const safe = (p) => {
-    const resolved = path.resolve(root, p)
-    // startsWith(root) пропускал бы соседние пути с общим префиксом
-    // (C:\work\proj vs C:\work\proj-old). Считаем через relative().
-    const rel = path.relative(root, resolved)
-    if (rel.startsWith('..') || path.isAbsolute(rel)) {
-      throw new Error(`Доступ за пределы рабочей директории: ${p}`)
-    }
-    return resolved
-  }
-
-  // Sandbox (вариант A): не даём команде выйти выше root.
-  // Это защитный барьер, а не полноценная изоляция ОС.
-  const assertCommandInsideRoot = (command) => {
-    const cmd = String(command || '')
-    const cdRe = /(?:^|[;&|]|\s)(?:cd|pushd)\s+([^;&|]+)/gi
-    let m
-    while ((m = cdRe.exec(cmd))) {
-      const raw = m[1].trim()
-      if (!raw || raw === '-') continue
-      const target = path.resolve(root, raw)
-      const rel = path.relative(root, target)
-      if (rel.startsWith('..') || path.isAbsolute(rel)) {
-        throw new Error('Sandbox: выход за пределы ' + root + ' запрещён (cd ' + raw + ')')
-      }
-    }
-  }
-  const runShell = (command, timeout = 30_000) =>
-    new Promise((resolve) => {
-      const options = {
-        cwd: workdir,
-        timeout,
-        maxBuffer: 1024 * 1024 * 8,
-        windowsHide: true,
-        env: { ...process.env },
-      }
-
-      if (process.platform === 'win32') {
-        options.shell = process.env.ComSpec || 'C:\\Windows\\System32\\cmd.exe'
-      } else {
-        options.shell = '/bin/sh'
-      }
-
-      exec(command, options, (err, stdout, stderr) => {
-        const out = (stdout || '').toString()
-        const errStr = (stderr || '').toString()
-
-        if (!err) {
-          const combined = (out + errStr).trim()
-          resolve(combined || '(команда выполнена без вывода)')
-          return
-        }
-
-        const parts = []
-
-        if (err.killed) {
-          parts.push(`⏱ Таймаут после ${timeout}ms — процесс убит.`)
-        } else if (err.code !== undefined && err.code !== null) {
-          parts.push(`Exit code: ${err.code}`)
-        } else if (err.signal) {
-          parts.push(`Убит сигналом: ${err.signal}`)
-        } else {
-          parts.push(`Ошибка: ${err.message}`)
-        }
-
-        if (out.trim()) parts.push(`stdout:\n${out.trim()}`)
-        if (errStr.trim()) parts.push(`stderr:\n${errStr.trim()}`)
-
-        resolve(parts.join('\n'))
-      })
-    })
-
-  const baseTools = [
-    {
-      name: 'Read',
-      description:
-        'Прочитать содержимое файла. Опционально: offset и limit (строки).',
-      parameters: { path: 'string', offset: 'number?', limit: 'number?' },
-      fn: async ({ path: p, offset, limit }) => {
-        const file = safe(p)
-        const content = await fs.readFile(file, 'utf-8')
-        const lines = content.split('\n')
-        const start = offset ?? 0
-        const end = limit ? start + limit : lines.length
-        return lines.slice(start, end).join('\n')
-      },
-    },
-
-    {
-      name: 'Write',
-      description: 'Создать или перезаписать файл.',
-      parameters: { path: 'string', content: 'string' },
-      fn: async ({ path: p, content }) => {
-        const file = safe(p)
-        if (undo) await undo.backup(file)
-        await fs.mkdir(path.dirname(file), { recursive: true })
-        await fs.writeFile(file, content, 'utf-8')
-        return `Файл записан: ${p}`
-      },
-    },
-
-    {
-      name: 'Edit',
-      description:
-        'Точечная замена строки в файле. old_string должен встречаться один раз.',
-      parameters: {
-        path: 'string',
-        old_string: 'string',
-        new_string: 'string',
-      },
-      fn: async ({ path: p, old_string, new_string }) => {
-        const file = safe(p)
-        if (typeof old_string !== 'string' || old_string === '') {
-          throw new Error('old_string пустой — нечего заменять.')
-        }
-        let content = await fs.readFile(file, 'utf-8')
-        const occurrences = content.split(old_string).length - 1
-        if (occurrences === 0) {
-          throw new Error(
-            `Строка не найдена в ${p}: "${old_string.slice(0, 60)}..."`,
-          )
-        }
-        if (occurrences > 1) {
-          throw new Error(
-            `Строка встречается ${occurrences} раз в ${p}. Уточните old_string.`,
-          )
-        }
-        if (undo) await undo.backup(file)
-        content = content.replace(old_string, new_string)
-        await fs.writeFile(file, content, 'utf-8')
-        return `Отредактирован: ${p}`
-      },
-    },
-
-    {
-      name: 'Bash',
-      description:
-        'Выполнить shell-команду в рабочей директории (cmd.exe на Windows, sh на Linux/macOS). ' +
-        'Не использовать для long-running процессов (серверы) — уйдут в таймаут. ' +
-        'Не использовать для команд, требующих интерактивного ввода. ' +
-        'Для git — инструменты Git*. Для интернета — WebFetch / WebSearch.',
-      parameters: { command: 'string', timeout: 'number?' },
-      fn: async ({ command, timeout }) => {
-        assertCommandInsideRoot(command)
-        return runShell(command, timeout)
-      },
-    },
-
-    {
-      name: 'Glob',
-      description: 'Найти файлы по glob-паттерну (например, "**/*.js").',
-      parameters: { pattern: 'string' },
-      fn: async ({ pattern }) => {
-        const { glob } = await import('fs/promises')
-        const results = []
-        for await (const f of glob(pattern, { cwd: workdir })) {
-          // Sandbox: игнорируем всё, что выходит за пределы root.
-          const abs = path.resolve(workdir, f)
-          const rel = path.relative(root, abs)
-          if (rel.startsWith('..') || path.isAbsolute(rel)) continue
-          results.push(f)
-        }
-        return results.length ? results.join('\n') : 'Ничего не найдено.'
-      },
-    },
-
-    {
-      name: 'Grep',
-      description: 'Поиск по содержимому файлов (регулярное выражение).',
-      parameters: { pattern: 'string', path: 'string?' },
-      fn: async ({ pattern, path: searchPath }) => {
-        const target = searchPath ? safe(searchPath) : workdir
-        if (process.platform === 'win32') {
-          const escaped = pattern.replace(/"/g, '\\"')
-          const scope = searchPath
-            ? '"' + target + '\\*'
-            : '*'
-          return runShell(`findstr /s /n /r /c:"${escaped}" ` + scope)
-        }
-        return runShell(
-          `grep -rn -E ${JSON.stringify(pattern)} ${JSON.stringify(target)} || true`,
-        )
-      },
-    },
-  ]
-
-  const gitTools = createGitTools(workdir)
-  const webTools = createWebTools()
-
-  const respondTool = {
-    name: 'respond',
-    description: 'Дать финальный ответ пользователю и завершить задачу.',
-    parameters: { message: 'string' },
-    fn: async ({ message }) => message,
-  }
-
-  return [...baseTools, ...gitTools, ...webTools, respondTool]
-}

package/src/transcript.js

@@ -1,46 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-
-export class Transcript {
-  constructor({ dir, enabled = true, sessionName = 'session' } = {}) {
-    this.enabled = enabled
-    this.file = null
-    this.stream = null
-    this.startedAt = Date.now()
-
-    if (!enabled) return
-
-    try {
-      fs.mkdirSync(dir, { recursive: true })
-      const stamp = new Date().toISOString().replace(/[:.]/g, '-')
-      this.file = path.join(dir, `${sessionName}-${stamp}.jsonl`)
-      this.stream = fs.createWriteStream(this.file, { flags: 'a' })
-      // Ошибки записи (диск переполнен, файл удалён и т.п.) приходят
-      // событием 'error'; без слушателя это uncaught exception.
-      this.stream.on('error', (e) => {
-        console.error(`transcript: ошибка записи: ${e.message}`)
-        this.enabled = false
-      })
-    } catch (e) {
-      console.error(`transcript: не удалось создать файл: ${e.message}`)
-      this.enabled = false
-    }
-  }
-
-  log(type, data = {}) {
-    if (!this.enabled || !this.stream) return
-    const entry = {
-      ts: new Date().toISOString(),
-      elapsed: Date.now() - this.startedAt,
-      type,
-      ...data,
-    }
-    try {
-      this.stream.write(JSON.stringify(entry) + '\n')
-    } catch {}
-  }
-
-  close() {
-    if (this.stream) this.stream.end()
-  }
-}

package/src/undo.js

@@ -1,101 +0,0 @@
-import fs from 'fs/promises'
-import path from 'path'
-import os from 'os'
-
-const UNDO_DIR = path.join(os.homedir(), '.zames', 'undo')
-const INDEX = path.join(UNDO_DIR, 'index.json')
-
-export class UndoStore {
-  constructor({ enabled = true, maxBackups = 200 } = {}) {
-    this.enabled = enabled
-    this.maxBackups = maxBackups
-  }
-
-  async _ensure() {
-    await fs.mkdir(UNDO_DIR, { recursive: true })
-  }
-
-  async _readIndex() {
-    try {
-      return JSON.parse(await fs.readFile(INDEX, 'utf-8'))
-    } catch {
-      return []
-    }
-  }
-
-  async _writeIndex(history) {
-    await fs.writeFile(INDEX, JSON.stringify(history, null, 2))
-  }
-
-  async backup(filePath) {
-    if (!this.enabled) return null
-    await this._ensure()
-
-    let content = null
-    let existed = false
-    try {
-      content = await fs.readFile(filePath)
-      existed = true
-    } catch (e) {
-      if (e.code !== 'ENOENT') throw e
-    }
-
-    const stamp = Date.now()
-    const hash = Buffer.from(filePath).toString('hex').slice(0, 16)
-
-    let backupFile = null
-    if (existed) {
-      backupFile = path.join(UNDO_DIR, `${stamp}-${hash}.bak`)
-      await fs.writeFile(backupFile, content)
-    }
-
-    const history = await this._readIndex()
-    history.push({ originalPath: filePath, existed, stamp, backupFile })
-
-    while (history.length > this.maxBackups) {
-      const old = history.shift()
-      if (old.backupFile) {
-        try {
-          await fs.unlink(old.backupFile)
-        } catch {}
-      }
-    }
-
-    await this._writeIndex(history)
-    return { originalPath: filePath, existed, stamp }
-  }
-
-  async undoLast() {
-    if (!this.enabled) return { ok: false, reason: 'undo отключён в конфиге' }
-    await this._ensure()
-
-    const history = await this._readIndex()
-    if (!history.length) return { ok: false, reason: 'история пуста' }
-
-    const record = history.pop()
-    const { originalPath, existed, backupFile } = record
-
-    try {
-      if (existed && backupFile) {
-        const data = await fs.readFile(backupFile)
-        await fs.writeFile(originalPath, data)
-        try {
-          await fs.unlink(backupFile)
-        } catch {}
-      } else {
-        try {
-          await fs.unlink(originalPath)
-        } catch {}
-      }
-      await this._writeIndex(history)
-      return { ok: true, record }
-    } catch (e) {
-      return { ok: false, reason: e.message }
-    }
-  }
-
-  async list(count = 10) {
-    const history = await this._readIndex()
-    return history.slice(-count).reverse()
-  }
-}

package/src/web.js

@@ -1,266 +0,0 @@
-import { chromium } from 'playwright'
-
-const DEFAULT_TIMEOUT = 20_000
-const MAX_TEXT = 12_000
-
-// Убирает скрипты, стили, и превращает HTML в читабельный текст.
-function htmlToText(html) {
-  // Удаляем блоки, которые не нужны
-  let s = html
-    .replace(/<script[\s\S]*?<\/script>/gi, '')
-    .replace(/<style[\s\S]*?<\/style>/gi, '')
-    .replace(/<noscript[\s\S]*?<\/noscript>/gi, '')
-    .replace(/<svg[\s\S]*?<\/svg>/gi, '')
-    .replace(/<!--[\s\S]*?-->/g, '')
-
-  // Ссылки: <a href="URL">text</a> → text (URL)
-  s = s.replace(
-    /<a\b[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi,
-    (_, href, text) => {
-      const t = text.replace(/<[^>]+>/g, '').trim()
-      return t ? `${t} (${href})` : href
-    },
-  )
-
-  // Заголовки, параграфы, BR → переводы строк
-  s = s
-    .replace(/<\/(h[1-6]|p|div|li|tr|section|article)>/gi, '\n')
-    .replace(/<br\s*\/?>/gi, '\n')
-    .replace(/<li[^>]*>/gi, '- ')
-    .replace(/<[^>]+>/g, '')
-
-  // HTML entities — базовые
-  s = s
-    .replace(/&nbsp;/g, ' ')
-    .replace(/&amp;/g, '&')
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-    .replace(/&quot;/g, '"')
-    .replace(/&#39;/g, "'")
-    .replace(/&mdash;/g, '—')
-    .replace(/&ndash;/g, '–')
-    .replace(/&hellip;/g, '…')
-    .replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n)))
-    .replace(/&#x([0-9a-f]+);/gi, (_, n) =>
-      String.fromCodePoint(parseInt(n, 16)),
-    )
-
-  // Сжимаем пустые строки
-  s = s
-    .split('\n')
-    .map((l) => l.replace(/[ \t]+/g, ' ').trim())
-    .filter(Boolean)
-    .join('\n')
-
-  return s
-}
-
-// fetch с редиректами и таймаутом
-async function httpFetch(
-  url,
-  { timeout = DEFAULT_TIMEOUT, headers = {} } = {},
-) {
-  const ctrl = new AbortController()
-  const t = setTimeout(() => ctrl.abort(), timeout)
-  try {
-    const res = await fetch(url, {
-      signal: ctrl.signal,
-      redirect: 'follow',
-      headers: {
-        'User-Agent':
-          'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) ds-agent/1.0',
-        'Accept-Language': 'en-US,en;q=0.9,ru;q=0.8',
-        ...headers,
-      },
-    })
-    const ct = res.headers.get('content-type') || ''
-    const body = await res.text()
-    return { status: res.status, url: res.url, contentType: ct, body }
-  } finally {
-    clearTimeout(t)
-  }
-}
-
-// Отдельный headless-браузер для JS-страниц.
-// Ленивая инициализация, чтобы не тратить ресурсы впустую.
-let _headless = null
-async function getHeadless() {
-  if (_headless) return _headless
-  _headless = await chromium.launch({
-    headless: true,
-    args: ['--disable-blink-features=AutomationControlled'],
-  })
-  return _headless
-}
-
-export async function closeWeb() {
-  if (_headless) {
-    try {
-      await _headless.close()
-    } catch {}
-    _headless = null
-  }
-}
-
-async function renderWithHeadless(url, { timeout = DEFAULT_TIMEOUT } = {}) {
-  const browser = await getHeadless()
-  const ctx = await browser.newContext({
-    userAgent:
-      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-  })
-  const page = await ctx.newPage()
-  try {
-    const resp = await page.goto(url, {
-      waitUntil: 'domcontentloaded',
-      timeout,
-    })
-    // Дать JS немного времени дорисовать
-    await page.waitForTimeout(1500)
-    const html = await page.content()
-    const status = resp ? resp.status() : 0
-    const finalUrl = page.url()
-    return { status, url: finalUrl, html }
-  } finally {
-    await ctx.close()
-  }
-}
-
-// ---------- инструменты ----------
-
-export function createWebTools() {
-  return [
-    {
-      name: 'WebFetch',
-      description:
-        'Загрузить URL и вернуть очищенный текст страницы (без HTML-тегов). ' +
-        'Используй для чтения документации, статей, README на GitHub. ' +
-        'Если страница рендерится JavaScript-ом и текст пустой — попробуй ещё раз с render=true.',
-      parameters: {
-        url: 'string',
-        render: 'boolean?',
-        maxChars: 'number?',
-      },
-      fn: async ({ url, render, maxChars }) => {
-        if (!/^https?:\/\//i.test(url)) {
-          return `Ошибка: URL должен начинаться с http:// или https://`
-        }
-
-        const limit = Math.min(Number(maxChars) || MAX_TEXT, 60_000)
-
-        try {
-          if (render) {
-            const r = await renderWithHeadless(url)
-            const text = htmlToText(r.html)
-            return formatResult(r.status, r.url, text, limit)
-          }
-
-          const r = await httpFetch(url)
-
-          // Если это JSON/plain text — вернуть как есть
-          if (
-            /application\/json|text\/plain|text\/markdown/i.test(r.contentType)
-          ) {
-            const trimmed = r.body.slice(0, limit)
-            return `HTTP ${r.status}  ${r.url}\nContent-Type: ${r.contentType}\n\n${trimmed}`
-          }
-
-          // HTML — почистить
-          const text = htmlToText(r.body)
-
-          // Если текста почти нет — вероятно JS-страница, дать намёк
-          if (text.length < 200) {
-            return (
-              `HTTP ${r.status}  ${r.url}\n` +
-              `Content-Type: ${r.contentType}\n\n` +
-              `Страница почти пустая в сыром HTML (${text.length} символов). ` +
-              `Похоже, контент рендерится JavaScript-ом. ` +
-              `Повтори вызов с render=true.\n\n---\n${text}`
-            )
-          }
-
-          return formatResult(r.status, r.url, text, limit)
-        } catch (e) {
-          return `Ошибка загрузки ${url}: ${e.message}`
-        }
-      },
-    },
-
-    {
-      name: 'WebSearch',
-      description:
-        'Поиск в интернете через DuckDuckGo HTML (без API-ключа). ' +
-        'Возвращает список результатов: заголовок, URL, краткое описание.',
-      parameters: {
-        query: 'string',
-        maxResults: 'number?',
-      },
-      fn: async ({ query, maxResults }) => {
-        const q = encodeURIComponent(query || '')
-        if (!q) return 'Ошибка: query пустой.'
-
-        const limit = Math.min(Math.max(Number(maxResults) || 8, 1), 20)
-
-        try {
-          const r = await httpFetch(
-            `https://html.duckduckgo.com/html/?q=${q}`,
-            {
-              timeout: 25_000,
-              headers: {
-                Accept: 'text/html,application/xhtml+xml',
-              },
-            },
-          )
-
-          if (r.status !== 200) {
-            return `DuckDuckGo вернул HTTP ${r.status}`
-          }
-
-          // Парсим простыми регексами. Формат html.duckduckgo.com стабильный.
-          const results = []
-          const re =
-            /<a[^>]*class="[^"]*result__a[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?(?:<a[^>]*class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>)?/gi
-
-          let m
-          while ((m = re.exec(r.body)) && results.length < limit) {
-            let href = m[1]
-            // DuckDuckGo заворачивает ссылки в редирект вида /l/?uddg=...
-            const uddgMatch = href.match(/[?&]uddg=([^&]+)/)
-            if (uddgMatch) href = decodeURIComponent(uddgMatch[1])
-
-            const title = htmlToText(m[2] || '').trim()
-            const snippet = htmlToText(m[3] || '').trim()
-
-            if (!title || !href) continue
-            results.push({ title, url: href, snippet })
-          }
-
-          if (!results.length) {
-            return `Результатов не найдено. Возможно, изменился формат выдачи DuckDuckGo.`
-          }
-
-          const lines = results.map(
-            (r, i) =>
-              `${i + 1}. ${r.title}\n   ${r.url}` +
-              (r.snippet ? `\n   ${r.snippet}` : ''),
-          )
-          return lines.join('\n\n')
-        } catch (e) {
-          return `Ошибка поиска: ${e.message}`
-        }
-      },
-    },
-  ]
-}
-
-function formatResult(status, url, text, limit) {
-  let out = text
-  let truncated = false
-  if (out.length > limit) {
-    out = out.slice(0, limit)
-    truncated = true
-  }
-  return (
-    `HTTP ${status}  ${url}\n\n${out}` +
-    (truncated ? `\n\n[...обрезано на ${limit} символах]` : '')
-  )
-}

package/src/xml-toolcall.js

@@ -1,69 +0,0 @@
-function unescapeXml(s) {
-  const A = String.fromCharCode(38) // ampersand
-  return String(s)
-    .split(A + "lt;").join(String.fromCharCode(60))
-    .split(A + "gt;").join(String.fromCharCode(62))
-    .split(A + "quot;").join(String.fromCharCode(34))
-    .split(A + "apos;").join(String.fromCharCode(39))
-    .split(A + "amp;").join(A)
-}
-
-function readAttr(attrs, name) {
-  const Q = String.fromCharCode(34)
-  const re = new RegExp(name + "[ ]*=[ ]*([" + Q + "]([^" + Q + "]*)[" + Q + "])")
-  const m = attrs.match(re)
-  return m ? m[2] : null
-}
-
-export function parseXmlToolCalls(text) {
-  if (!text || typeof text !== "string") return null
-  if (!/<[^>]*invoke/i.test(text)) return null
-
-  const invokeRe = /<[^>]*?invoke([^>]*)>/gi
-  const calls = []
-  let m
-  while ((m = invokeRe.exec(text)) !== null) {
-    const attrs = m[1] || ""
-    const name = readAttr(attrs, "name")
-    if (!name) continue
-
-    const rest = text.slice(invokeRe.lastIndex)
-    const closeRe = /<\/[^>]*?invoke[^>]*>/i
-    const closeMatch = closeRe.exec(rest)
-    const body = closeMatch ? rest.slice(0, closeMatch.index) : rest
-
-    const args = {}
-    const paramRe = /<[^>]*?parameter([^>]*)>([\s\S]*?)<\/[^>]*?parameter[^>]*>/gi
-    let p
-    while ((p = paramRe.exec(body)) !== null) {
-      const pname = readAttr(p[1] || "", "name")
-      if (!pname) continue
-      const isString = /string[ ]*=[ ]*"?true"?/i.test(p[1] || "")
-      let value = unescapeXml(p[2])
-      if (!isString) {
-        try { value = JSON.parse(value) } catch (e) {}
-      }
-      args[pname] = value
-    }
-
-    // Некоторые модели кладут весь JSON-объект аргументов в один
-    // parameter с именем args. Разворачиваем, чтобы не было
-    // {args: {args: {...}}}.
-    let finalArgs = args
-    const keys = Object.keys(args)
-    if (
-      keys.length === 1 &&
-      keys[0] === 'args' &&
-      args.args &&
-      typeof args.args === 'object' &&
-      !Array.isArray(args.args)
-    ) {
-      finalArgs = args.args
-    }
-
-    calls.push({ tool: name, args: finalArgs })
-  }
-
-  if (!calls.length) return null
-  return calls.length === 1 ? calls[0] : calls
-}