@jpssff/vanor 0.1.0

package/base/transport/cli.js

@@ -0,0 +1,417 @@
+// CLI 交互层：readline TUI、流式渲染、工具展示、审批、slash 命令、底部状态条。
+
+import readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { c } from "../utils.js";
+import { listSessions, listUserMessages } from "../core/session.js";
+import { createI18n } from "../i18n/index.js";
+import { summarizeSkills } from "../skills/loader.js";
+import { StatusBar } from "./statusbar.js";
+import { displayWidth, TerminalUI } from "./tui.js";
+
+export function helpText(t = createI18n("en").t) {
+  return t("cli.help.text");
+}
+
+function preview(text, n = 240) {
+  const s = String(text || "").replace(/\s+/g, " ").trim();
+  return s.length > n ? s.slice(0, n) + "…" : s;
+}
+
+export function formatMessageTime(value) {
+  const d = new Date(value);
+  if (!Number.isFinite(d.getTime())) return String(value || "-").slice(0, 19);
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+
+export function formatUserMessageRow(message, contentLimit = 160) {
+  return `${formatMessageTime(message.time)}  ${preview(message.content, contentLimit)}`;
+}
+
+export function availableModels(config, currentModel = "") {
+  const out = [];
+  const seen = new Set();
+  const add = (model) => {
+    const value = String(model || "").trim();
+    if (!value || seen.has(value)) return;
+    seen.add(value);
+    out.push(value);
+  };
+
+  add(currentModel);
+  add(config.llm?.defaultModel);
+  for (const model of config.llm?.fallback || []) add(model);
+
+  for (const [providerName, provider] of Object.entries(config.llm?.providers || {})) {
+    for (const model of provider.models || []) {
+      const id = typeof model === "string" ? model : model?.id || model?.name || "";
+      if (!id) continue;
+      add(id.startsWith(`${providerName}/`) ? id : `${providerName}/${id}`);
+    }
+  }
+  return out;
+}
+
+export function searchModels(models, query) {
+  const q = String(query || "").trim().toLowerCase();
+  if (!q) return models;
+  return models.filter((model) => model.toLowerCase().includes(q));
+}
+
+/**
+ * 把 readline 的 clearScreenDown(ESC[0J / ESC[J) 降级为“清到行尾”(ESC[K)。
+ * 退格/重绘时 readline 会擦除光标下方的所有内容，连带删除底部状态条造成闪烁；
+ * 降级后只清当前输入行的残留，不再触及下方状态行。其它清屏序列（如 ESC[2K）不受影响。
+ */
+export function downgradeClearScreenDown(chunk) {
+  return typeof chunk === "string" ? chunk.replace(/\x1b\[0?J/g, "\x1b[K") : chunk;
+}
+
+export function wrapText(text, width, indent = "") {
+  const max = Math.max(10, width);
+  const out = [];
+  for (const rawLine of String(text ?? "").split(/\r?\n/)) {
+    const words = rawLine.split(/(\s+)/).filter(Boolean);
+    let line = indent;
+
+    const pushLine = () => {
+      out.push(line.trimEnd());
+      line = indent;
+    };
+
+    for (const word of words.length ? words : [""]) {
+      if (/^\s+$/.test(word)) {
+        if (line !== indent) line += " ";
+        continue;
+      }
+
+      if (displayWidth(line + word) <= max) {
+        line += word;
+        continue;
+      }
+
+      if (line !== indent) pushLine();
+      for (const ch of Array.from(word)) {
+        if (displayWidth(line + ch) > max && line !== indent) pushLine();
+        line += ch;
+      }
+    }
+    pushLine();
+  }
+  return out.join("\n");
+}
+
+export function formatConfirmMessage(message, cols = 80, t = createI18n("en").t) {
+  const width = Math.max(24, Math.min(cols || 80, 120));
+  return `${t("cli.confirmMessage")}\n${wrapText(message, width, "  ")}\n`;
+}
+
+export async function startCli(harness, { config }) {
+  const useTui = !!(stdin.isTTY && stdout.isTTY);
+  // 过滤 readline 的清屏序列：退格/重绘时 readline 会用 clearScreenDown(ESC[0J)
+  // 擦掉光标下方，连带删除底部状态条，造成一闪一闪。这里把它降级为“清到行尾”
+  // (ESC[K)，只清当前输入行的残留，不再触及下方的状态行。
+  const rlOutput = stdout.isTTY
+    ? new Proxy(stdout, {
+        get(target, prop) {
+          if (prop === "write") {
+            return (chunk, enc, cb) => target.write(downgradeClearScreenDown(chunk), enc, cb);
+          }
+          const val = target[prop];
+          return typeof val === "function" ? val.bind(target) : val;
+        },
+      })
+    : stdout;
+  const rl = useTui ? null : readline.createInterface({ input: stdin, output: rlOutput });
+
+  const statusBar = new StatusBar(() => ({
+    used: harness.session.estimatedTokens(),
+    total: harness.config.agent?.contextWindow ?? config.agent?.contextWindow ?? 256000,
+    model: harness.model,
+    cwd: harness.security.workspaceRoot,
+    approval: harness.security.approval,
+  }), { reservedInputLines: useTui ? 1 : 0 });
+  const tui = useTui ? new TerminalUI({ input: stdin, output: stdout, statusBar, prompt: c.cyan("› ") }) : null;
+  const write = (s) => (tui ? tui.write(s) : stdout.write(s));
+  const readInput = () => (tui ? tui.readLine() : rl.question(c.cyan("› ")));
+  const askInline = (prompt) => (tui ? tui.ask(prompt) : rl.question(prompt));
+  const t = (key, vars) => harness.i18n.t(key, vars);
+
+  let running = false;
+  let abort = null;
+  let lastInput = "";
+
+  const cleanup = () => {
+    harness.saveState?.();
+    tui?.disable();
+    statusBar.disable();
+  };
+  process.on("exit", cleanup);
+
+  statusBar.enable();
+  tui?.enable();
+  write(c.bold(c.cyan(t("cli.banner"))) + "\n");
+  write(c.gray(`${t("cli.intro")}\n\n`));
+  if (harness.sessionRestored) {
+    write(c.gray(`${t("cli.restored", { id: harness.session.id, count: harness.session.messages.length })}\n\n`));
+  }
+
+  const onSigint = () => {
+    if (running && abort) {
+      abort.abort();
+      write(c.yellow(`\n${t("cli.interruptRequested")}\n`));
+    } else {
+      cleanup();
+      write(`\n${t("cli.goodbye")}\n\n`);
+      rl?.close();
+      process.exit(0);
+    }
+  };
+  if (tui) tui.onSigint = onSigint;
+  else rl.on("SIGINT", onSigint);
+
+  const handlers = {
+    _streaming: false,
+    onText(delta) {
+      if (!this._streaming) {
+        write(c.green("vanor ▸ "));
+        this._streaming = true;
+      }
+      write(delta);
+    },
+    onAssistant() {
+      if (this._streaming) {
+        write("\n");
+        this._streaming = false;
+      }
+    },
+    onToolCalls(calls) {
+      for (const call of calls) {
+        const arg =
+          call.name === "exec"
+            ? call.arguments?.command
+            : call.arguments?.path || JSON.stringify(call.arguments || {});
+        write(c.gray(`  ⚙ ${call.name} ${preview(arg, 80)}\n`));
+      }
+    },
+    onToolResult(call, msg) {
+      const mark = msg.meta?.isError ? c.red("  ✗ ") : c.gray("  ✓ ");
+      write(mark + c.gray(preview(msg.content)) + "\n");
+    },
+    onError(e) {
+      write(c.red(`\n${t("cli.error", { message: e.message })}\n`));
+    },
+    confirm: async (message) => {
+      write(c.yellow(formatConfirmMessage(message, stdout.columns || 80, t)));
+      const prompt = c.yellow(t("cli.confirmPrompt"));
+      const ans = tui ? await tui.ask(prompt) : await rl.question(prompt);
+      return /^y(es)?$/i.test(ans.trim());
+    },
+  };
+
+  async function chooseModel(matches, query) {
+    write(c.gray(`${t("cli.modelMatched", { count: matches.length })}\n`));
+    matches.forEach((model, index) => {
+      const mark = model === harness.model ? " *" : "";
+      write(c.gray(`  ${index + 1}. ${model}${mark}\n`));
+    });
+    const ans = (await askInline(c.cyan(t("cli.chooseModel", { count: matches.length })))).trim();
+    if (!ans) return "";
+    const n = Number(ans);
+    if (!Number.isInteger(n) || n < 1 || n > matches.length) {
+      write(c.red(`${t("cli.invalidChoice")}\n`));
+      return "";
+    }
+    return matches[n - 1];
+  }
+
+  async function handleSlash(input) {
+    const [cmd, ...rest] = input.slice(1).split(/\s+/);
+    const arg = rest.join(" ").trim();
+    switch (cmd) {
+      case "help":
+        write(helpText(t) + "\n");
+        return true;
+      case "exit":
+      case "quit":
+        cleanup();
+        rl?.close();
+        process.exit(0);
+        return true;
+      case "new":
+      case "reset":
+        harness.newSession();
+        write(c.gray(`${t("cli.newSession")}\n`));
+        return true;
+      case "compact":
+        write(c.gray(`${t("cli.compactRunning")}\n`));
+        statusBar.setBusy(true);
+        statusBar.render(true);
+        try {
+          await harness.compactNow();
+          write(c.gray(`${t("cli.compactDone")}\n`));
+        } finally {
+          statusBar.setBusy(false);
+        }
+        return true;
+      case "model":
+        if (arg) {
+          const models = availableModels(harness.config, harness.model);
+          const matches = searchModels(models, arg);
+          const exact = matches.find((model) => model.toLowerCase() === arg.toLowerCase());
+          let target = exact || (matches.length === 1 ? matches[0] : "");
+          if (!target && matches.length > 1) target = await chooseModel(matches, arg);
+          if (!target && matches.length === 0) target = arg;
+          if (!target) return true;
+          try {
+            harness.setModel(target);
+            write(c.gray(`${t("cli.modelChanged", { model: target })}\n`));
+          } catch (e) {
+            write(c.red(`${t("cli.modelSwitchFailed", { message: e.message })}\n`));
+            if (matches.length === 0 && models.length) {
+              write(c.gray(`${t("cli.searchableModels")}\n`));
+              for (const model of models) write(c.gray(`- ${model}\n`));
+            }
+          }
+        } else {
+          write(c.gray(`${t("cli.currentModel", { model: harness.model })}\n`));
+        }
+        return true;
+      case "language":
+        if (!arg) {
+          write(
+            c.gray(
+              `${t("cli.language.current", {
+                language: harness.i18n.language,
+                configured: harness.i18n.configured || "auto",
+                source: harness.i18n.source || "",
+              })}\n`,
+            ),
+          );
+          return true;
+        }
+        try {
+          const next = harness.setLanguage(arg);
+          write(
+            c.gray(
+              `${next.t("cli.language.changed", {
+                language: next.language,
+                configured: next.configured || "auto",
+                source: next.source || "",
+              })}\n`,
+            ),
+          );
+          statusBar.render(true);
+        } catch (e) {
+          write(c.red(`${e.message}\n`));
+        }
+        return true;
+      case "usage": {
+        const u = harness.session.usage;
+        write(
+          c.gray(`${t("cli.usage", { prompt: u.promptTokens, completion: u.completionTokens, total: u.totalTokens })}\n`),
+        );
+        return true;
+      }
+      case "messages": {
+        const messages = listUserMessages(harness.session.paths, harness.session.id);
+        if (!messages.length) {
+          write(c.gray(`${t("cli.messagesNone")}\n`));
+          return true;
+        }
+        write(c.gray(`${t("cli.messagesHeader")}\n`));
+        for (const message of messages) write(c.gray(formatUserMessageRow(message) + "\n"));
+        return true;
+      }
+      case "skills": {
+        harness.reloadSkills?.();
+        if (!harness.skills.length) write(c.gray(`${t("cli.skillsNone")}\n`));
+        for (const s of harness.skills) write(c.gray(`- ${s.name}: ${s.description}\n`));
+        const summary = summarizeSkills(harness.skills);
+        write(c.gray(`\n${t("cli.skillsTotal", { count: summary.total })}\n`));
+        for (const item of summary.byDir) write(c.gray(`- ${item.dir}: ${item.count}\n`));
+        return true;
+      }
+      case "reload": {
+        const r = harness.reloadConfig({ force: true });
+        if (r.error) write(c.red(`${t("cli.reloadFailed", { error: r.error })}\n`));
+        else if (r.reloaded) write(c.gray(`${t("cli.reloadDone", { model: harness.model })}\n`));
+        else write(c.gray(`${t("cli.reloadUnchanged")}\n`));
+        statusBar.render(true);
+        return true;
+      }
+      case "auto-run":
+        if (arg === "off") {
+          harness.security.setApproval(harness.security.initialApproval);
+          write(c.gray(`${t("cli.approvalRestored", { approval: harness.security.approval })}\n`));
+        } else {
+          harness.security.setApproval("auto");
+          write(c.yellow(`${t("cli.autoRunEnabled")}\n`));
+        }
+        statusBar.render();
+        return true;
+      case "retry":
+        if (!lastInput) {
+          write(c.gray(`${t("cli.retryNone")}\n`));
+          return true;
+        }
+        return false; // 交回主循环用 lastInput 重跑
+      default:
+        write(c.red(`${t("cli.unknownSlash", { cmd })}\n`));
+        return true;
+    }
+  }
+
+  // 主循环
+  for (;;) {
+    statusBar.render();
+    let input;
+    try {
+      input = (await readInput()).trim();
+    } catch {
+      break; // rl 关闭
+    }
+    if (!input) continue;
+    tui?.echoInput(input);
+
+    if (input.startsWith("/")) {
+      const consumed = await handleSlash(input);
+      if (consumed) continue;
+      if (input.slice(1).startsWith("retry")) input = lastInput; // /retry
+    } else {
+      lastInput = input;
+    }
+
+    running = true;
+    abort = new AbortController();
+    statusBar.setBusy(true);
+    try {
+      const result = await harness.runTurn(input, handlers, abort.signal);
+      if (result.maxIterations) write(c.yellow(`${t("cli.maxIterations")}\n`));
+      if (result.aborted) write(c.yellow(`${t("cli.aborted")}\n`));
+    } catch (e) {
+      write(c.red(`${t("cli.runtimeError", { message: e.message })}\n`));
+    } finally {
+      running = false;
+      abort = null;
+      statusBar.setBusy(false);
+      write("\n");
+    }
+  }
+
+  cleanup();
+}
+
+export function printSessions(paths, i18n = createI18n("en")) {
+  const { t } = i18n;
+  const sessions = listSessions(paths);
+  if (!sessions.length) {
+    stdout.write(`${t("cli.sessionsNone")}\n`);
+    return;
+  }
+  for (const s of sessions.slice(0, 20)) {
+    const when = new Date(s.mtime).toLocaleString();
+    stdout.write(`${t("cli.sessionRow", { id: s.id, count: s.messageCount, model: s.model, when })}\n`);
+  }
+}

package/base/transport/message.js

@@ -0,0 +1,81 @@
+// 统一消息协议。Core / Loop 全程使用 Message，仅在 LLM 边界转换为各 provider 格式。
+
+import { genId, nowIso } from "../utils.js";
+
+/**
+ * @typedef {"system"|"user"|"assistant"|"tool"} Role
+ * @typedef {{ id:string, name:string, arguments:any }} ToolCall
+ * @typedef {{
+ *   id:string, role:Role, content:string,
+ *   toolCalls?:ToolCall[], toolCallId?:string, name?:string,
+ *   channel?:string, meta?:Record<string,any>
+ * }} Message
+ */
+
+function base(role, content, extra = {}) {
+  return {
+    id: genId("msg"),
+    role,
+    content: content ?? "",
+    meta: { timestamp: nowIso(), ...(extra.meta || {}) },
+    ...stripMeta(extra),
+  };
+}
+
+function stripMeta(extra) {
+  const { meta, ...rest } = extra;
+  return rest;
+}
+
+export function systemMessage(content, extra = {}) {
+  return base("system", content, extra);
+}
+
+export function userMessage(content, extra = {}) {
+  return base("user", content, extra);
+}
+
+/** assistant 消息，可带 toolCalls。 */
+export function assistantMessage(content, toolCalls = [], extra = {}) {
+  const msg = base("assistant", content, extra);
+  if (toolCalls && toolCalls.length) msg.toolCalls = toolCalls;
+  return msg;
+}
+
+/** tool 结果消息，对应某次 toolCall。 */
+export function toolMessage({ toolCallId, name, content, isError = false }) {
+  const msg = base("tool", content);
+  msg.toolCallId = toolCallId;
+  msg.name = name;
+  if (isError) msg.meta.isError = true;
+  return msg;
+}
+
+/**
+ * 校验角色交替规则（provider 强约束）。
+ * @returns {string[]} 违规说明，空表示通过。
+ */
+export function validateAlternation(messages) {
+  const errors = [];
+  let prev = null;
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    if (m.role === "system" && i !== 0) {
+      errors.push(`#${i} system 消息只能位于开头`);
+    }
+    if (prev) {
+      if (prev.role === "assistant" && m.role === "assistant") {
+        errors.push(`#${i} 连续两条 assistant`);
+      }
+      if (prev.role === "user" && m.role === "user") {
+        errors.push(`#${i} 连续两条 user`);
+      }
+      // assistant 带 toolCalls 后，必须跟随 tool 结果
+      if (prev.role === "assistant" && prev.toolCalls?.length && m.role !== "tool") {
+        errors.push(`#${i} assistant 发起工具调用后应跟随 tool 结果`);
+      }
+    }
+    prev = m;
+  }
+  return errors;
+}

package/base/transport/statusbar.js

@@ -0,0 +1,117 @@
+// 终端底部固定状态条：利用 ANSI 滚动区域（DECSTBM）将最后一行独立出来，
+// 对话与输入在其上方滚动。常驻显示上下文用量 / 模型 / 工作区，忙碌时以旋转字符提示。
+
+import os from "node:os";
+import { c } from "../utils.js";
+
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+function shortenPath(p, max = 36) {
+  const home = os.homedir();
+  let s = p && p.startsWith(home) ? "~" + p.slice(home.length) : p || "";
+  if (s.length > max) s = "…" + s.slice(-(max - 1));
+  return s;
+}
+
+export class StatusBar {
+  /** @param {() => {used:number,total:number,model:string,cwd:string}} getState */
+  constructor(getState, { reservedInputLines = 0 } = {}) {
+    this.getState = getState;
+    this.reservedInputLines = reservedInputLines;
+    this.frame = 0;
+    this._loop = null;
+    this.busy = false;
+    this.enabled = false;
+    this._onResize = null;
+    this._last = ""; // 上次写入的状态行内容，用于脏检查防闪
+  }
+
+  enable() {
+    if (!process.stdout.isTTY) return; // 非 TTY（管道/重定向）不启用
+    this.enabled = true;
+    this._setRegion();
+    this._onResize = () => {
+      this._setRegion();
+      this.render(true); // 尺寸变化需强制重画
+    };
+    process.stdout.on("resize", this._onResize);
+    // 常驻刷新：忙碌时驱动 spinner 动画；空闲时内容不变，render 通过脏检查直接跳过，
+    // 既保证被意外擦除时能补画，又不会产生周期性抖动。
+    this._loop = setInterval(() => {
+      if (this.busy) this.frame++;
+      this.render();
+    }, 120);
+    this._loop.unref?.();
+    this.render(true);
+  }
+
+  _rows() {
+    return process.stdout.rows || 24;
+  }
+  _cols() {
+    return process.stdout.columns || 80;
+  }
+
+  statusRow() {
+    return this._rows();
+  }
+
+  inputRow() {
+    return Math.max(1, this.statusRow() - this.reservedInputLines);
+  }
+
+  scrollBottom() {
+    return Math.max(1, this.inputRow() - 1);
+  }
+
+  // 滚动区设为 1..scrollBottom，底部按需留给输入行与状态条
+  _setRegion() {
+    const bottom = this.scrollBottom();
+    process.stdout.write(`\x1b[1;${bottom}r\x1b[${bottom};1H`);
+  }
+
+  render(force = false) {
+    if (!this.enabled) return;
+    const rows = this.statusRow();
+    const cols = this._cols();
+    const st = this.getState() || {};
+    const used = st.used ?? 0;
+    const total = st.total ?? 0;
+    const pct = total ? Math.min(100, Math.round((used / total) * 100)) : 0;
+    const spin = this.busy ? FRAMES[this.frame % FRAMES.length] : "●";
+
+    const ctx = `ctx ${used}/${total} (${pct}%)`;
+    const rest = `${ctx}  │  ${st.model || ""}  │  ${shortenPath(st.cwd || "")}`;
+    const flag = st.approval === "auto" ? " ⚡auto" : "";
+    const budget = Math.max(0, cols - 4 - flag.length);
+    const text = rest.length > budget ? rest.slice(0, Math.max(0, budget - 1)) + "…" : rest;
+
+    const line = `${c.cyan(spin)}${flag ? c.yellow(flag) : ""} ${c.dim(text)}`;
+    // 脏检查：内容未变则不重写，避免空闲时周期性擦写造成闪烁
+    if (!force && line === this._last) return;
+    this._last = line;
+    // 保存光标 → 移到状态行行首 → 写内容 → 清到行尾（避免“先清整行”的空窗）→ 恢复光标
+    process.stdout.write(`\x1b7\x1b[${rows};1H${line}\x1b[K\x1b8`);
+  }
+
+  /** 切换忙碌态：忙碌时 spinner 旋转，空闲时定格为静态符号；状态条始终常驻。 */
+  setBusy(b) {
+    this.busy = b;
+    this.render();
+  }
+
+  disable() {
+    if (!this.enabled) return;
+    if (this._loop) {
+      clearInterval(this._loop);
+      this._loop = null;
+    }
+    if (this._onResize) process.stdout.off("resize", this._onResize);
+    const firstReservedRow = Math.min(this.inputRow(), this.statusRow());
+    // 重置滚动区，并清掉底部保留区域（固定输入行 + 状态栏）。
+    // 光标停在清理后的第一行，后续退出文案会写在干净位置，不残留状态栏内容。
+    process.stdout.write(`\x1b[r\x1b[${firstReservedRow};1H\x1b[J`);
+    this.enabled = false;
+    this._last = "";
+  }
+}