@jpssff/vanor 0.1.0

package/base/transport/tui.js

@@ -0,0 +1,397 @@
+// 轻量终端输入控制器：将输出滚动区与底部输入行分离。
+// Agent 运行时用户可以继续编辑下一轮输入，输出滚动不会带走输入草稿。
+
+const ANSI_RE = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+const ENABLE_BRACKETED_PASTE = "\x1b[?2004h";
+const DISABLE_BRACKETED_PASTE = "\x1b[?2004l";
+
+export function stripAnsi(s) {
+  return String(s || "").replace(ANSI_RE, "");
+}
+
+function chars(s) {
+  return Array.from(String(s || ""));
+}
+
+export function charWidth(ch) {
+  if (!ch) return 0;
+  const cp = ch.codePointAt(0);
+  if (cp <= 0x1f || (cp >= 0x7f && cp <= 0x9f)) return 0;
+  // 常见组合附加符号不前进光标
+  if (
+    (cp >= 0x0300 && cp <= 0x036f) ||
+    (cp >= 0x1ab0 && cp <= 0x1aff) ||
+    (cp >= 0x1dc0 && cp <= 0x1dff) ||
+    (cp >= 0x20d0 && cp <= 0x20ff) ||
+    (cp >= 0xfe20 && cp <= 0xfe2f)
+  ) {
+    return 0;
+  }
+  // CJK、全角标点、Hangul、常见 emoji 在终端通常占 2 列
+  if (
+    (cp >= 0x1100 && cp <= 0x115f) ||
+    cp === 0x2329 ||
+    cp === 0x232a ||
+    (cp >= 0x2e80 && cp <= 0xa4cf && cp !== 0x303f) ||
+    (cp >= 0xac00 && cp <= 0xd7a3) ||
+    (cp >= 0xf900 && cp <= 0xfaff) ||
+    (cp >= 0xfe10 && cp <= 0xfe19) ||
+    (cp >= 0xfe30 && cp <= 0xfe6f) ||
+    (cp >= 0xff00 && cp <= 0xff60) ||
+    (cp >= 0xffe0 && cp <= 0xffe6) ||
+    (cp >= 0x1f300 && cp <= 0x1faff)
+  ) {
+    return 2;
+  }
+  return 1;
+}
+
+export function displayWidth(s) {
+  return chars(stripAnsi(s)).reduce((n, ch) => n + charWidth(ch), 0);
+}
+
+function printable(s) {
+  return s && !s.startsWith("\x1b") && !/[\x00-\x08\x0b-\x1f\x7f]/.test(s);
+}
+
+function inputVisual(ch) {
+  return ch === "\n" ? "↵ " : ch;
+}
+
+function inputSliceWidth(all, start, end) {
+  return displayWidth(all.slice(start, end).map(inputVisual).join(""));
+}
+
+export function advanceCursor(pos, chunk) {
+  const cols = Math.max(1, pos.cols || 80);
+  const bottom = Math.max(1, pos.bottom || pos.row || 1);
+  let row = Math.max(1, pos.row || bottom);
+  let col = Math.max(1, pos.col || 1);
+  const text = stripAnsi(chunk);
+
+  for (const ch of chars(text)) {
+    if (ch === "\r") {
+      col = 1;
+      continue;
+    }
+    if (ch === "\n") {
+      col = 1;
+      row = row >= bottom ? bottom : row + 1;
+      continue;
+    }
+    const w = charWidth(ch);
+    if (w === 0) continue;
+    col += w;
+    if (col > cols) {
+      col = 1;
+      row = row >= bottom ? bottom : row + 1;
+    }
+  }
+  return { row, col };
+}
+
+export class TerminalUI {
+  constructor({ input, output, statusBar, prompt = "› " }) {
+    this.input = input;
+    this.output = output;
+    this.statusBar = statusBar;
+    this.prompt = prompt;
+    this.buffer = "";
+    this.cursor = 0;
+    this.enabled = false;
+    this.queue = [];
+    this.waiters = [];
+    this._onData = (data) => this._handleData(data);
+    this.onSigint = null;
+    this._ask = null;
+    this.outRow = 1;
+    this.outCol = 1;
+    this._pasting = false;
+    this._pendingEsc = "";
+    this.history = [];
+    this.historyIndex = null;
+    this._draftBeforeHistory = "";
+  }
+
+  enable() {
+    if (!this.input.isTTY || !this.output.isTTY) return false;
+    this.enabled = true;
+    this._resetOutputCursor();
+    this.input.setEncoding?.("utf8");
+    this.input.setRawMode?.(true);
+    this.input.resume?.();
+    this.input.on("data", this._onData);
+    this.output.write(ENABLE_BRACKETED_PASTE);
+    this.renderInput(true);
+    return true;
+  }
+
+  disable() {
+    if (!this.enabled) return;
+    this.input.off("data", this._onData);
+    this.input.setRawMode?.(false);
+    this.output.write(DISABLE_BRACKETED_PASTE);
+    this.enabled = false;
+  }
+
+  _rows() {
+    return this.output.rows || 24;
+  }
+
+  _cols() {
+    return this.output.columns || 80;
+  }
+
+  _inputRow() {
+    return this.statusBar?.inputRow?.() || Math.max(1, this._rows() - 1);
+  }
+
+  _scrollBottom() {
+    return this.statusBar?.scrollBottom?.() || Math.max(1, this._rows() - 2);
+  }
+
+  _resetOutputCursor() {
+    this.outRow = this._scrollBottom();
+    this.outCol = 1;
+  }
+
+  write(chunk) {
+    if (!this.enabled) return this.output.write(chunk);
+    const text = String(chunk ?? "");
+    if (!text) return true;
+    this.output.write(`\x1b7\x1b[${this.outRow};${this.outCol}H${text}\x1b8`);
+    const next = advanceCursor({ row: this.outRow, col: this.outCol, cols: this._cols(), bottom: this._scrollBottom() }, text);
+    this.outRow = next.row;
+    this.outCol = next.col;
+    this.renderInput(true);
+    return true;
+  }
+
+  echoInput(line) {
+    this.write(`${this.prompt}${line}\n`);
+  }
+
+  readLine() {
+    const queued = this.queue.shift();
+    if (queued !== undefined) return Promise.resolve(queued);
+    return new Promise((resolve) => this.waiters.push(resolve));
+  }
+
+  ask(prompt) {
+    const saved = { prompt: this.prompt, buffer: this.buffer, cursor: this.cursor };
+    this.prompt = prompt;
+    this.buffer = "";
+    this.cursor = 0;
+    this.renderInput(true);
+    return new Promise((resolve) => {
+      this._ask = {
+        resolve: (line) => {
+          this._ask = null;
+          this.prompt = saved.prompt;
+          this.buffer = saved.buffer;
+          this.cursor = saved.cursor;
+          this.renderInput(true);
+          resolve(line);
+        },
+      };
+    });
+  }
+
+  renderInput(force = false) {
+    if (!this.enabled && !force) return;
+    const row = this._inputRow();
+    const cols = this._cols();
+    const promptCols = displayWidth(this.prompt);
+    const available = Math.max(1, cols - promptCols - 1);
+    const all = chars(this.buffer);
+    const cursor = Math.min(this.cursor, all.length);
+    let start = 0;
+    while (inputSliceWidth(all, start, cursor) > available) start++;
+    let end = start;
+    let used = 0;
+    while (end < all.length) {
+      const w = displayWidth(inputVisual(all[end]));
+      if (used + w > available) break;
+      used += w;
+      end++;
+    }
+    const visible = all.slice(start, end).map(inputVisual).join("");
+    const visibleCursorCols = inputSliceWidth(all, start, cursor);
+    const cursorCol = Math.max(1, Math.min(cols, promptCols + visibleCursorCols + 1));
+    this.output.write(`\x1b[${row};1H\x1b[2K${this.prompt}${visible}\x1b[${row};${cursorCol}H`);
+  }
+
+  _resolveLine(line) {
+    const waiter = this.waiters.shift();
+    if (waiter) waiter(line);
+    else this.queue.push(line);
+  }
+
+  _submit() {
+    const line = this.buffer;
+    this.buffer = "";
+    this.cursor = 0;
+    this.renderInput(true);
+    if (this._ask) {
+      this._ask.resolve(line);
+    } else {
+      this._remember(line);
+      this._resolveLine(line);
+    }
+  }
+
+  _remember(line) {
+    if (!String(line).trim()) return;
+    if (this.history.at(-1) !== line) this.history.push(line);
+    if (this.history.length > 200) this.history.shift();
+    this.historyIndex = null;
+    this._draftBeforeHistory = "";
+  }
+
+  _setBuffer(text, { fromHistory = false } = {}) {
+    this.buffer = String(text || "");
+    this.cursor = chars(this.buffer).length;
+    if (!fromHistory) {
+      this.historyIndex = null;
+      this._draftBeforeHistory = "";
+    }
+    this.renderInput(true);
+  }
+
+  _navigateHistory(delta) {
+    if (this._ask || !this.history.length) return;
+    if (this.historyIndex === null) {
+      this._draftBeforeHistory = this.buffer;
+      this.historyIndex = this.history.length;
+    }
+    this.historyIndex = Math.max(0, Math.min(this.history.length, this.historyIndex + delta));
+    const next = this.historyIndex === this.history.length ? this._draftBeforeHistory : this.history[this.historyIndex];
+    this._setBuffer(next, { fromHistory: true });
+  }
+
+  _insert(s, { multiline = false } = {}) {
+    const all = chars(this.buffer);
+    const text = multiline ? String(s).replace(/\r\n/g, "\n").replace(/\r/g, "\n") : String(s);
+    const ins = chars(text).filter((ch) => (multiline && ch === "\n") || printable(ch));
+    if (!ins.length) return;
+    this.historyIndex = null;
+    this._draftBeforeHistory = "";
+    all.splice(this.cursor, 0, ...ins);
+    this.buffer = all.join("");
+    this.cursor += ins.length;
+    this.renderInput(true);
+  }
+
+  _backspace() {
+    if (this.cursor <= 0) return;
+    this.historyIndex = null;
+    this._draftBeforeHistory = "";
+    const all = chars(this.buffer);
+    all.splice(this.cursor - 1, 1);
+    this.buffer = all.join("");
+    this.cursor -= 1;
+    this.renderInput(true);
+  }
+
+  _delete() {
+    const all = chars(this.buffer);
+    if (this.cursor >= all.length) return;
+    this.historyIndex = null;
+    this._draftBeforeHistory = "";
+    all.splice(this.cursor, 1);
+    this.buffer = all.join("");
+    this.renderInput(true);
+  }
+
+  _handleEscape(s) {
+    if (s === "\x1b[A") {
+      this._navigateHistory(-1);
+      return true;
+    }
+    if (s === "\x1b[B") {
+      this._navigateHistory(1);
+      return true;
+    }
+    if (s === "\x1b[D") {
+      this.cursor = Math.max(0, this.cursor - 1);
+      this.renderInput(true);
+      return true;
+    }
+    if (s === "\x1b[C") {
+      this.cursor = Math.min(chars(this.buffer).length, this.cursor + 1);
+      this.renderInput(true);
+      return true;
+    }
+    if (s === "\x1b[3~") {
+      this._delete();
+      return true;
+    }
+    return false;
+  }
+
+  _handleData(data) {
+    let s = String(data);
+    if (this._pendingEsc) {
+      s = this._pendingEsc + s;
+      this._pendingEsc = "";
+    }
+    if (s === "\x1b" || s === "\x1b[") {
+      this._pendingEsc = s;
+      return;
+    }
+    if (this._pasting) {
+      const end = s.indexOf(PASTE_END);
+      if (end === -1) {
+        this._insert(s, { multiline: true });
+        return;
+      }
+      this._insert(s.slice(0, end), { multiline: true });
+      this._pasting = false;
+      const rest = s.slice(end + PASTE_END.length);
+      if (rest) this._handleData(rest);
+      return;
+    }
+
+    const start = s.indexOf(PASTE_START);
+    if (start !== -1) {
+      const before = s.slice(0, start);
+      if (before) this._handleData(before);
+      this._pasting = true;
+      const rest = s.slice(start + PASTE_START.length);
+      if (rest) this._handleData(rest);
+      return;
+    }
+
+    if (s.startsWith("\x1b")) {
+      if (this._handleEscape(s)) return;
+      return; // 未识别的控制序列直接忽略，避免拆包时漏出 [A/[B 等字符
+    }
+
+    if (chars(s).length > 1 && !s.startsWith("\x1b")) {
+      for (const ch of chars(s)) this._handleData(ch);
+      return;
+    }
+    if (s === "\x03") {
+      if (this._ask) return this._ask.resolve("");
+      return this.onSigint?.();
+    }
+    if (s === "\r" || s === "\n") return this._submit();
+    if (s === "\x7f" || s === "\b") return this._backspace();
+    if (s === "\x01") {
+      this.cursor = 0;
+      return this.renderInput(true);
+    }
+    if (s === "\x05") {
+      this.cursor = chars(this.buffer).length;
+      return this.renderInput(true);
+    }
+    if (s === "\x15") {
+      this.buffer = "";
+      this.cursor = 0;
+      return this.renderInput(true);
+    }
+    return this._insert(s);
+  }
+}

package/base/utils.js

@@ -0,0 +1,150 @@
+// 通用工具函数：零依赖，被各层只读引用。
+
+import fs from "node:fs";
+import path from "node:path";
+import { createI18n } from "./i18n/index.js";
+
+const defaultT = createI18n("en").t;
+import { homedir } from "node:os";
+
+/** 生成带前缀的短唯一 id，如 msg_lr3k2a9x。 */
+export function genId(prefix = "id") {
+  return `${prefix}_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export function nowIso() {
+  return new Date().toISOString();
+}
+
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/** 将路径中的 ~ 展开为用户主目录。 */
+export function expandHome(p) {
+  if (!p || typeof p !== "string") return p;
+  if (p === "~") return homedir();
+  if (p.startsWith("~/")) return path.join(homedir(), p.slice(2));
+  return p;
+}
+
+export function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+export function readJsonSafe(file, fallback = null) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+export function writeJson(file, value) {
+  ensureDir(path.dirname(file));
+  fs.writeFileSync(file, JSON.stringify(value, null, 2));
+}
+
+/** 粗略 token 估算：约 4 字符 / token。 */
+export function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.ceil(String(text).length / 4);
+}
+
+// ---- 终端颜色（无依赖，遵循 NO_COLOR 与非 TTY 自动降级）----
+
+const colorEnabled = () => Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+
+function wrap(code) {
+  return (s) => (colorEnabled() ? `\x1b[${code}m${s}\x1b[0m` : String(s));
+}
+
+export const c = {
+  red: wrap("31"),
+  green: wrap("32"),
+  yellow: wrap("33"),
+  blue: wrap("34"),
+  magenta: wrap("35"),
+  cyan: wrap("36"),
+  gray: wrap("90"),
+  bold: wrap("1"),
+  dim: wrap("2"),
+};
+
+// ---- 最小 JSON Schema 校验器（够工具参数使用）----
+
+function checkType(t, v) {
+  switch (t) {
+    case "string":
+      return typeof v === "string";
+    case "number":
+      return typeof v === "number" && !Number.isNaN(v);
+    case "integer":
+      return Number.isInteger(v);
+    case "boolean":
+      return typeof v === "boolean";
+    case "object":
+      return v !== null && typeof v === "object" && !Array.isArray(v);
+    case "array":
+      return Array.isArray(v);
+    case "null":
+      return v === null;
+    default:
+      return true;
+  }
+}
+
+/**
+ * 校验 value 是否符合简化版 JSON Schema。
+ * 支持 type / required / properties / items / enum。
+ * @returns {string[]} 错误信息数组，空数组表示通过。
+ */
+export function validateSchema(schema, value, p = "", t = defaultT) {
+  const errors = [];
+  if (!schema || typeof schema !== "object") return errors;
+  const loc = p || "(root)";
+
+  if (schema.type && !checkType(schema.type, value)) {
+    errors.push(t("schema.expectedType", { loc, type: schema.type }));
+    return errors;
+  }
+  if (schema.enum && !schema.enum.includes(value)) {
+    errors.push(t("schema.enumValue", { loc, values: JSON.stringify(schema.enum) }));
+  }
+  if (schema.type === "object" && checkType("object", value)) {
+    for (const req of schema.required || []) {
+      if (!(req in value)) errors.push(t("schema.required", { loc, field: req }));
+    }
+    for (const [k, sub] of Object.entries(schema.properties || {})) {
+      if (k in value) {
+        errors.push(...validateSchema(sub, value[k], p ? `${p}.${k}` : k, t));
+      }
+    }
+  }
+  if (schema.type === "array" && Array.isArray(value) && schema.items) {
+    value.forEach((item, i) => {
+      errors.push(...validateSchema(schema.items, item, `${p}[${i}]`, t));
+    });
+  }
+  return errors;
+}
+
+/** 深合并普通对象（数组与标量直接覆盖）。 */
+export function deepMerge(base, override) {
+  if (!isPlainObject(base) || !isPlainObject(override)) return override ?? base;
+  const out = { ...base };
+  for (const [k, v] of Object.entries(override)) {
+    out[k] = isPlainObject(v) && isPlainObject(base[k]) ? deepMerge(base[k], v) : v;
+  }
+  return out;
+}
+
+export function isPlainObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+
+/** 将字符串按 glob（仅支持 *）转为匹配函数，用于 allow/deny。 */
+export function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}