dgxay-code-cli 0.0.0-stage → 1.0.0

package/src/cli/index.js

@@ -0,0 +1,228 @@
+'use strict';
+
+/**
+ * CLI 调度入口：全局选项 → 子命令分发 → 无参数时进入交互模式。
+ */
+
+const { COLORS } = require('./ansi');
+const { parseArgs } = require('./args');
+const { COMMANDS, findCommand } = require('./command-table');
+const print = require('./print');
+const { VERSION, BIN } = require('../services/version');
+
+const GLOBAL_OPTIONS = [
+  { name: 'help', alias: 'h', type: 'boolean', desc: '显示帮助' },
+  { name: 'version', alias: 'v', type: 'boolean', desc: '显示版本号' },
+  { name: 'home', type: 'string', valueName: 'dir', desc: '覆盖数据目录（默认 ~/.dcb，也可用 DGXAY_HOME）' },
+  { name: 'debug', type: 'boolean', desc: '输出调试信息与堆栈' },
+  { name: 'no-color', type: 'boolean', desc: '关闭彩色输出（等同 NO_COLOR=1）' },
+  { name: 'print', alias: 'p', type: 'boolean', desc: '单次运行：发送提示词后输出结果并退出' },
+  { name: 'prompt', type: 'string', valueName: 'text', desc: '单次运行的提示词' },
+  { name: 'output', alias: 'o', type: 'string', valueName: 'format', desc: '输出格式：text / json（配合 --print）' },
+  { name: 'mode', alias: 'm', type: 'string', valueName: 'mode', desc: '模式：chat / work' },
+  { name: 'permission', type: 'string', valueName: 'level', desc: '权限：none / normal / auto / full' },
+  { name: 'workspace', alias: 'C', type: 'string', valueName: 'dir', desc: '工作空间目录' },
+  { name: 'model', type: 'string', valueName: 'id', desc: '指定模型' },
+  { name: 'provider', type: 'string', valueName: 'name', desc: '指定供应商' },
+  { name: 'skill', type: 'string', valueName: 'name', desc: '本次运行启用的技能' },
+  { name: 'resume', alias: 'r', type: 'string', valueName: 'id|index', desc: '恢复指定会话' },
+  { name: 'continue', alias: 'c', type: 'boolean', desc: '恢复最近一次会话' },
+  { name: 'yes', alias: 'y', type: 'boolean', desc: '自动同意所有授权请求（仅单次运行，慎用）' }
+];
+
+const LOGO = [
+  '  ██████╗  ██████╗ ██╗  ██╗ █████╗ ██╗   ██╗',
+  '  ██╔══██╗██╔════╝ ╚██╗██╔╝██╔══██╗╚██╗ ██╔╝',
+  '  ██║  ██║██║  ███╗ ╚███╔╝ ███████║ ╚████╔╝ ',
+  '  ██║  ██║██║   ██║ ██╔██╗ ██╔══██║  ╚██╔╝  ',
+  '  ██████╔╝╚██████╔╝██╔╝ ██╗██║  ██║   ██║   ',
+  '  ╚═════╝  ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝   '
+];
+
+function showBanner() {
+  for (const line of LOGO) process.stdout.write(`${COLORS.accent(line)}\n`);
+  process.stdout.write(
+    `${COLORS.faint(`  v${VERSION} · 多协议 AI 编码助手 · 输入 /help 查看命令 · Ctrl+C 退出`)}\n\n`
+  );
+}
+
+function showHelp() {
+  process.stdout.write(`\n${COLORS.bold(`${BIN} — DgxayCode 命令行版`)} ${COLORS.faint(`v${VERSION}`)}\n\n`);
+  process.stdout.write(`${COLORS.faint('用法')}\n  ${BIN} [选项] [命令] [参数…]\n\n`);
+  process.stdout.write(`${COLORS.faint('常用命令')}\n`);
+  const rows = [
+    [`${BIN}`, '进入交互模式'],
+    [`${BIN} "帮我写一个 Python 脚本"`, '单次执行后退出'],
+    [`${BIN} run -p "..." -C ./project`, '指定工作空间单次执行'],
+    [`${BIN} config init`, '首次配置（填写供应商与 API Key）'],
+    [`${BIN} doctor`, '自检：配置、目录、模型连通性'],
+    [`${BIN} <命令> --help`, '查看某个命令的详细用法']
+  ];
+  const width = Math.max(...rows.map(([cmd]) => cmd.length));
+  for (const [cmd, desc] of rows) {
+    process.stdout.write(`  ${COLORS.cyan(cmd.padEnd(width))}  ${COLORS.faint(desc)}\n`);
+  }
+  process.stdout.write(`\n${COLORS.faint('子命令')}\n`);
+  const nameWidth = Math.max(...COMMANDS.map((cmd) => cmd.name.length));
+  for (const cmd of COMMANDS) {
+    const aliases = cmd.aliases?.length ? COLORS.faint(` (${cmd.aliases.join(', ')})`) : '';
+    process.stdout.write(`  ${COLORS.accent(cmd.name.padEnd(nameWidth))}  ${cmd.summary || ''}${aliases}\n`);
+  }
+  process.stdout.write(`\n${COLORS.faint('全局选项')}\n`);
+  const flags = GLOBAL_OPTIONS.map((opt) => {
+    const alias = opt.alias ? `-${opt.alias}, ` : '    ';
+    const value = opt.type !== 'boolean' ? ` <${opt.valueName || opt.type}>` : '';
+    return [`${alias}--${opt.name}${value}`, opt.desc];
+  });
+  const flagWidth = Math.max(...flags.map(([flag]) => flag.length));
+  for (const [flag, desc] of flags) {
+    process.stdout.write(`  ${COLORS.cyan(flag.padEnd(flagWidth))}  ${COLORS.faint(desc)}\n`);
+  }
+  process.stdout.write(
+    `\n${COLORS.faint('说明')} 配置与对话保存在 ${COLORS.faint('~/.dcb')}（可用 DGXAY_HOME 覆盖），可用 ${COLORS.faint(
+      `${BIN} config path`
+    )} 查看。\n\n`
+  );
+}
+
+/** 把全局选项转成运行参数 */
+function runtimeOptions(options) {
+  return {
+    mode: options.mode,
+    permission: options.permission,
+    workspace: options.workspace,
+    model: options.model,
+    provider: options.provider,
+    skill: options.skill,
+    resume: options.resume,
+    continueLast: options.continue,
+    yes: options.yes,
+    output: options.output || 'text',
+    print: Boolean(options.print || options.prompt)
+  };
+}
+
+/** --home 必须在读取配置前生效：去掉该参数后重新进入 main */
+function extractHome(argv) {
+  const args = argv.slice();
+  let home = null;
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (token === '--home') {
+      if (args[i + 1]) {
+        home = args[i + 1];
+        args.splice(i, 2);
+        return { args, home };
+      }
+      args.splice(i, 1);
+      return { args, home };
+    }
+    if (token.startsWith('--home=')) {
+      home = token.slice('--home='.length);
+      args.splice(i, 1);
+      return { args, home };
+    }
+  }
+  return { args, home };
+}
+
+/** 清掉本项目模块的缓存，让 config.js 用新的 DGXAY_HOME 重新计算数据目录 */
+function resetModuleCache() {
+  process.env.DGXAY_HOME = process.env.DGXAY_HOME || '';
+  if (!process.env.DGXAY_HOME) delete process.env.DGXAY_HOME;
+  const sep = require('path').sep;
+  const root = require('path').join(__dirname, '..');
+  for (const key of Object.keys(require.cache)) {
+    if (key.startsWith(root) && !key.includes(`${sep}bin${sep}`)) delete require.cache[key];
+  }
+}
+
+async function main(argv) {
+  let args = Array.isArray(argv) ? argv.slice() : [];
+
+  const extracted = extractHome(args);
+  if (extracted.home !== null) {
+    process.env.DGXAY_HOME = extracted.home;
+    args = extracted.args;
+    resetModuleCache();
+  }
+
+  let parsed;
+  try {
+    parsed = parseArgs(args, GLOBAL_OPTIONS.map((opt) => ({ ...opt })), { allowUnknown: true });
+  } catch (err) {
+    print.fail(err.message);
+    return 2;
+  }
+
+  if (parsed.options.noColor) process.env.NO_COLOR = '1';
+  if (parsed.options.debug) process.env.DGXAY_DEBUG = '1';
+
+  if (parsed.options.version) {
+    process.stdout.write(`${VERSION}\n`);
+    return 0;
+  }
+
+  const commandName = parsed.positionals[0];
+  const command = commandName ? findCommand(commandName) : null;
+
+  // 只有命令 token 本身放在位置参数里；它后面的全部原始参数原样交给子命令，
+  // 否则子命令自己的选项（如 provider add --model）会被全局解析器吞掉。
+  const commandIndex = commandName ? args.lastIndexOf(commandName) : -1;
+  const commandArgv = command ? args.slice(commandIndex + 1) : [];
+
+  if (parsed.options.help && !command) {
+    showHelp();
+    return 0;
+  }
+
+  const runtime = runtimeOptions(parsed.options);
+
+  if (command) {
+    if (parsed.options.help) {
+      print.usage(command);
+      return 0;
+    }
+    try {
+      const result = await command.run({
+        argv: commandArgv,
+        globalOptions: parsed.options,
+        runtime,
+        io: { command }
+      });
+      return typeof result === 'number' ? result : 0;
+    } catch (err) {
+      if (err?.userError) {
+        print.fail(err.message);
+        print.hint(`运行 ${BIN} ${command.name} --help 查看用法`);
+        return 2;
+      }
+      print.fail(err?.message || String(err));
+      if (process.env.DGXAY_DEBUG === '1' && err?.stack) process.stderr.write(`${err.stack}\n`);
+      return 1;
+    }
+  }
+
+  // 不是子命令：整串参数当作单次运行的提示词；否则进入交互模式
+  const prompt = parsed.positionals.join(' ').trim();
+  const repl = require('./repl');
+  try {
+    return await repl.start({
+      ...runtime,
+      initialPrompt: prompt,
+      // 只有显式给了提示词或 --print 才是单次运行；
+      // 用 -c / -r 指定会话但没有提示词时，仍是交互模式（恢复会话后继续输入）
+      single: Boolean(prompt) || Boolean(runtime.print)
+    });
+  } catch (err) {
+    if (err?.userError) {
+      print.fail(err.message);
+      return 2;
+    }
+    print.fail(err?.message || String(err));
+    if (process.env.DGXAY_DEBUG === '1' && err?.stack) process.stderr.write(`${err.stack}\n`);
+    return 1;
+  }
+}
+
+module.exports = { main, GLOBAL_OPTIONS, showHelp, showBanner, LOGO };

package/src/cli/print.js

@@ -0,0 +1,148 @@
+'use strict';
+
+/**
+ * 输出辅助：统一成功 / 提示 / 错误 / 表格 / 键值列表的样式。
+ */
+
+const { COLORS, SIGN, displayWidth, truncate, termWidth, renderMarkdown } = require('./ansi');
+
+function write(text = '') {
+  process.stdout.write(`${text}\n`);
+}
+
+function print(text = '') {
+  write(text);
+}
+
+function blank() {
+  write('');
+}
+
+function ok(message) {
+  write(`${COLORS.green(SIGN.ok)} ${message}`);
+}
+
+function info(message) {
+  write(`${COLORS.accent(SIGN.bullet)} ${message}`);
+}
+
+function warn(message) {
+  write(`${COLORS.yellow('!')} ${message}`);
+}
+
+function fail(message) {
+  process.stderr.write(`${COLORS.red(SIGN.fail)} ${message}\n`);
+}
+
+function hint(message) {
+  write(COLORS.faint(message));
+}
+
+function heading(text) {
+  write(`${COLORS.bold(text)}`);
+}
+
+function markdown(text, width = termWidth()) {
+  process.stdout.write(renderMarkdown(text, { width }));
+}
+
+/** 按显示宽度补空格（中文占两格，padEnd 会算错） */
+function padWidth(text, width) {
+  const visible = displayWidth(text);
+  return visible >= width ? String(text) : `${text}${' '.repeat(width - visible)}`;
+}
+
+/** 键值列表：条目 { label, value, tone } */
+function keyValue(rows, options = {}) {
+  const indent = options.indent || '  ';
+  const width = Math.max(...rows.map((row) => displayWidth(String(row.label))));
+  for (const row of rows) {
+    const label = `${indent}${COLORS.faint(padWidth(String(row.label), width))}`;
+    const value = row.tone ? COLORS[row.tone](String(row.value ?? '')) : String(row.value ?? '');
+    if (row.multiline) {
+      write(label);
+      for (const line of String(row.value ?? '').split('\n')) write(`${indent}${' '.repeat(width + 2)}${line}`);
+    } else {
+      write(`${label}  ${value}`);
+    }
+  }
+}
+
+/** 表格：columns 决定列宽；rows 为二维数组 */
+function table(columns, rows) {
+  const widths = columns.map((col, index) => {
+    const head = displayWidth(col.title);
+    const cells = rows.map((row) => displayWidth(String(row[index] ?? '')));
+    const max = Math.min(col.max || 60, Math.max(head, ...cells));
+    return Math.max(head, Math.min(max, Math.max(head, ...cells)));
+  });
+  const total = widths.reduce((sum, w) => sum + w, 0) + (columns.length - 1) * 2;
+  const limit = termWidth() - 1;
+  if (total > limit) {
+    const overflow = total - limit;
+    const widest = widths.indexOf(Math.max(...widths));
+    widths[widest] = Math.max(6, widths[widest] - overflow);
+  }
+  const line = (cells, painter) =>
+    cells
+      .map((cell, index) => {
+        const text = truncate(String(cell ?? '').replace(/\n/g, ' '), widths[index]);
+        const pad = ' '.repeat(Math.max(0, widths[index] - displayWidth(text)));
+        return painter ? painter(`${text}${pad}`) : `${text}${pad}`;
+      })
+      .join('  ')
+      .replace(/\s+$/, '');
+  write(line(columns.map((col) => col.title), COLORS.faint));
+  write(COLORS.faint(widths.map((w) => '─'.repeat(w)).join('  ')));
+  for (const row of rows) write(line(row));
+}
+
+/** 简单的使用说明 */
+function usage(command) {
+  if (!command) return;
+  write(`${COLORS.bold(`dgxay ${command.name}`)}${command.summary ? COLORS.faint(` — ${command.summary}`) : ''}`);
+  if (command.usage) {
+    blank();
+    write(COLORS.faint('用法'));
+    write(`  ${command.usage}`);
+  }
+  if (command.examples?.length) {
+    blank();
+    write(COLORS.faint('示例'));
+    for (const example of command.examples) write(`  ${COLORS.cyan(example)}`);
+  }
+  if (command.options?.length) {
+    blank();
+    write(COLORS.faint('选项'));
+    const rows = command.options.map((opt) => {
+      const alias = opt.alias ? [].concat(opt.alias).map((a) => (a.length === 1 ? `-${a}` : a)).join(', ') : '';
+      const name = `--${opt.name}${opt.type && opt.type !== 'boolean' ? ` <${opt.valueName || opt.type}>` : ''}`;
+      return [alias ? `${alias}, ${name}` : name, opt.desc || ''];
+    });
+    rows.push(['-h, --help', '显示帮助']);
+    const width = Math.max(...rows.map(([flag]) => displayWidth(flag)));
+    for (const [flag, desc] of rows) write(`  ${COLORS.cyan(padWidth(flag, width))}  ${COLORS.faint(desc)}`);
+  }
+  if (command.subcommands?.length) {
+    blank();
+    write(COLORS.faint('子命令'));
+    const width = Math.max(...command.subcommands.map(([, name]) => displayWidth(name)));
+    for (const [name, desc] of command.subcommands) write(`  ${COLORS.accent(padWidth(name, width))}  ${desc}`);
+  }
+}
+
+module.exports = {
+  write,
+  print,
+  blank,
+  ok,
+  info,
+  warn,
+  fail,
+  hint,
+  heading,
+  keyValue,
+  table,
+  usage,
+  markdown
+};

package/src/cli/render.js

@@ -0,0 +1,324 @@
+'use strict';
+
+/**
+ * 流式渲染：把 agent 事件流翻译成终端输出。
+ *
+ * 关键约束（来自真实 Windows 控制台的实测）：不能依赖「光标上移 + 清行」来重绘。
+ * 很多终端（尤其是某些 Windows 控制台组合）会忽略 `\x1b[nA`，
+ * 于是每次重绘都会把整块内容当成新行往下追加，出现「一段一行」的堆积。
+ *
+ * 因此只使用所有终端都支持的原始能力：`\r` 回到行首、空格覆盖清尾，绝不回退到上面的行。
+ *
+ * 渲染策略：
+ *   - 流式阶段：只在**最后一行**用 \r 实时刷新（纯文本，不解析 Markdown），
+ *     用户看到的是一行不断变长的文字；
+ *   - 收尾阶段：抹掉这行预览，再用 Markdown 渲染器把整段完整输出一次，
+ *     表格 / 代码块 / 标题才能正确对齐，且只发生一次。
+ */
+
+const { COLORS, SIGN, displayWidth, truncate, termWidth, renderMarkdown } = require('./ansi');
+
+const TOOL_TITLES = {
+  list_directory: '列出目录',
+  read_file: '读取文件',
+  write_file: '写入文件',
+  create_directory: '创建目录',
+  delete_path: '删除',
+  run_command: '执行命令',
+  fetch_url: '访问网络',
+  install_mcp_server: '安装 MCP'
+};
+
+function toolSummary(name, argsRaw) {
+  let args = {};
+  try {
+    args = argsRaw ? JSON.parse(argsRaw) : {};
+  } catch {
+    args = {};
+  }
+  const title = TOOL_TITLES[name] || name;
+  const target = args.path || args.url || args.command || args.name || '';
+  return target
+    ? `${title} ${truncate(String(target).replace(/\s+/g, ' '), Math.max(20, termWidth() - 24))}`
+    : title;
+}
+
+/** 把一行过长的文本按显示宽度折开（流式预览用，纯文本） */
+function foldLine(text, width) {
+  const limit = Math.max(20, width);
+  if (displayWidth(text) <= limit) return [text];
+  const out = [];
+  let current = '';
+  let currentWidth = 0;
+  for (const char of text) {
+    const w = displayWidth(char);
+    if (currentWidth + w > limit) {
+      out.push(current);
+      current = '';
+      currentWidth = 0;
+    }
+    current += char;
+    currentWidth += w;
+  }
+  if (current) out.push(current);
+  return out.length ? out : [''];
+}
+
+class StreamRenderer {
+  constructor(options = {}) {
+    this.out = options.output || process.stdout;
+    this.editor = options.editor || null;
+    // 只有真正的交互终端才做「行内实时刷新」；管道输出保持纯净
+    const tty = Boolean(this.out.isTTY);
+    this.live = options.redraw !== undefined ? Boolean(options.redraw) : tty;
+    this.width = Math.max(20, (options.width || termWidth()) - 1);
+    this.reset();
+  }
+
+  reset() {
+    this.started = false;
+    /** 已收到的完整正文 */
+    this.text = '';
+    /** 当前物理行屏幕上的内容（用于 \r 覆盖清尾） */
+    this.onScreen = '';
+    /** 收到的换行数，用来决定收尾时是否需要重排 */
+    this.newlines = 0;
+    this.tools = new Map();
+    this.reasoning = '';
+    this.reasoningStart = 0;
+    this.reasoningMs = 0;
+    this.suspended = false;
+  }
+
+  /* ------------------------------ 编辑器协调 ------------------------------ */
+
+  suspend() {
+    if (this.suspended) return;
+    this.editor?.suspend();
+    this.suspended = true;
+  }
+
+  resume() {
+    if (!this.suspended) return;
+    this.suspended = false;
+    this.editor?.resume();
+  }
+
+  /* ------------------------------ 行内刷新 ------------------------------ */
+
+  /**
+   * 把「当前物理行」替换成 text：\r 回到行首，写出 text，再用空格擦掉多余的尾部。
+   * 全程不换行、不上移，因此无论终端是否支持光标控制都不会堆积。
+   */
+  repaintLine(text) {
+    const visible = displayWidth(text);
+    const previous = displayWidth(this.onScreen);
+    const pad = Math.max(0, previous - visible);
+    this.out.write(`\r${text}${' '.repeat(pad)}`);
+    if (pad) this.out.write(`\b`.repeat(pad));
+    this.onScreen = text;
+  }
+
+  /** 结束当前物理行 */
+  breakLine() {
+    this.out.write('\n');
+    this.onScreen = '';
+  }
+
+  /* ------------------------------ 正文 ------------------------------ */
+
+  ensureHeader() {
+    if (this.started) return;
+    this.started = true;
+    this.suspend();
+    this.out.write(`\n${COLORS.accent('•')} ${COLORS.bold('DgxayCode')}\n`);
+    this.onScreen = '';
+  }
+
+  /** 流式阶段：交互终端才刷新预览行；管道模式下只累积，收尾时一次性输出 */
+  writeText(text) {
+    this.ensureHeader();
+    this.text += text;
+    this.newlines += (text.match(/\n/g) || []).length;
+    if (!this.live) return;
+
+    const lines = this.text.split('\n');
+    const tail = lines[lines.length - 1];
+    const folded = foldLine(tail, this.width);
+    // 只保留最后一段可视宽度内的一行，避免预览超出屏幕后折行导致覆盖错位
+    const preview = folded[folded.length - 1];
+    this.repaintLine(preview);
+  }
+
+  /**
+   * 收尾：抹掉预览行，按 Markdown 完整输出正文（只发生一次）。
+   */
+  finalizeText() {
+    if (!this.text) {
+      this.onScreen = '';
+      return;
+    }
+    // 预览行 → 清空（仅交互终端才有预览行）
+    if (this.live && this.onScreen) this.repaintLine('');
+    const rendered = renderMarkdown(this.text, { width: this.width });
+    if (rendered && rendered.trim()) {
+      this.out.write(rendered);
+      if (!rendered.endsWith('\n')) this.breakLine();
+    }
+    this.text = '';
+    this.newlines = 0;
+    this.onScreen = '';
+  }
+
+  /* ------------------------------ 事件分发 ------------------------------ */
+
+  handle(event) {
+    switch (event.type) {
+      case 'status':
+        return;
+      case 'delta':
+        if (!event.text) return;
+        this.writeText(event.text);
+        return;
+      case 'reasoning':
+        if (!event.text) return;
+        if (!this.reasoningStart) this.reasoningStart = Date.now();
+        this.reasoning += event.text;
+        this.ensureHeader();
+        return;
+      case 'tool':
+        this.onTool(event);
+        return;
+      case 'review-start':
+        this.endInline();
+        this.out.write(`${COLORS.faint(`  ${SIGN.run} 正在自动审查 ${event.name}…`)}\n`);
+        return;
+      case 'review':
+        this.endInline();
+        if (event.decision === 'allow') {
+          this.out.write(
+            `${COLORS.green(`  ${SIGN.ok}`)} ${COLORS.green('自动审查放行')} ${COLORS.faint(
+              `${event.reviewer || ''} · ${event.reason || ''}`
+            )}\n`
+          );
+        } else {
+          this.out.write(
+            `${COLORS.yellow(`  ${SIGN.run}`)} ${COLORS.yellow('自动审查判定可疑，转交确认')} ${COLORS.faint(
+              event.reason || ''
+            )}\n`
+          );
+        }
+        return;
+      case 'waiting':
+        this.endInline();
+        this.out.write(`${COLORS.faint(`  ${SIGN.run} 等待用户确认 ${event.name}…`)}\n`);
+        return;
+      case 'file':
+        this.endInline();
+        this.out.write(
+          `${COLORS.green(`  ${SIGN.ok}`)} ${COLORS.dim(
+            event.action === 'deleted' ? '删除' : event.action === 'updated' ? '更新' : '创建'
+          )} ${COLORS.cyan(event.display || event.path)}${event.bytes ? COLORS.faint(` (${event.bytes} B)`) : ''}\n`
+        );
+        return;
+      case 'done':
+      case 'error':
+      case 'aborted':
+        this.finish(event);
+        return;
+      default:
+        return;
+    }
+  }
+
+  /** 正文中途插入了其他内容（工具调用、审查提示等）：先把已有正文按 Markdown 落地 */
+  endInline() {
+    if (this.text) this.finalizeText();
+    if (this.onScreen) this.breakLine();
+  }
+
+  onTool(event) {
+    this.endInline();
+    const record = this.tools.get(event.id) || {};
+    if (event.args) record.args = event.args;
+    const summary = record.summary || toolSummary(event.name, event.args || record.args);
+    this.tools.set(event.id, { ...record, name: event.name, status: event.status, summary });
+
+    if (event.status === 'running') {
+      this.out.write(`${COLORS.faint(`  ${SIGN.run} ${summary}…`)}\n`);
+      return;
+    }
+    const detail = this.toolDetail(event);
+    if (event.status === 'ok') {
+      this.out.write(
+        `${COLORS.green(`  ${SIGN.ok}`)} ${COLORS.dim(summary)}${detail ? COLORS.faint(` · ${detail}`) : ''}\n`
+      );
+    } else {
+      const firstLine = String(event.output || '')
+        .split('\n')
+        .find((line) => line.trim() && !line.startsWith('$ '));
+      this.out.write(
+        `${COLORS.red(`  ${SIGN.fail}`)} ${COLORS.dim(summary)}${
+          firstLine ? COLORS.red(` · ${truncate(firstLine, 80)}`) : ''
+        }\n`
+      );
+    }
+    if (event.review?.reason) {
+      this.out.write(
+        `${COLORS.faint(`     ${event.review.source === 'auto' ? '自动审查' : '确认'} · ${event.review.reason}`)}\n`
+      );
+    }
+  }
+
+  toolDetail(event) {
+    const output = String(event.output || '');
+    if (event.name === 'read_file') return `${output.length} 字符`;
+    if (event.name === 'run_command') {
+      const exit = output.match(/\[exit\] code=(\S+)/);
+      if (exit) return `退出码 ${exit[1]}`;
+      return `${output.split('\n').filter(Boolean).length} 行输出`;
+    }
+    if (event.name === 'list_directory') return `${output.split('\n').filter(Boolean).length} 项`;
+    if (event.name === 'fetch_url') {
+      const match = output.match(/^HTTP (\d{3})/);
+      return match ? `HTTP ${match[1]}` : '';
+    }
+    if (event.name === 'install_mcp_server') return '已保存配置';
+    return '';
+  }
+
+  finish(event) {
+    if (this.reasoningStart && !this.reasoningMs) this.reasoningMs = Date.now() - this.reasoningStart;
+    const hadText = Boolean(this.text.trim());
+
+    if (event.type === 'error') {
+      this.endInline();
+      this.out.write(`\n${COLORS.red(`${SIGN.fail} 出错了：${event.message}`)}\n`);
+    } else if (event.type === 'aborted') {
+      this.finalizeText();
+      this.out.write(`${COLORS.yellow(`${SIGN.bullet} 已停止生成`)}\n`);
+    } else {
+      this.finalizeText();
+      if (!hadText && !this.tools.size && !this.reasoning.trim()) {
+        this.out.write(`${COLORS.faint('（模型没有返回内容）')}\n`);
+      }
+    }
+
+    if (this.reasoning.trim()) {
+      const ms = this.reasoningMs || 0;
+      const seconds = ms > 0 ? (ms / 1000).toFixed(ms < 10000 ? 1 : 0) : '0';
+      this.out.write(`${COLORS.faint(`  ⌁ 已思考 ${seconds}s · ${this.reasoning.length} 字符`)}\n`);
+    }
+    if (event.usage) {
+      const usage = event.usage;
+      const input = usage.input_tokens ?? usage.prompt_tokens ?? usage.inputTokens ?? null;
+      const output = usage.output_tokens ?? usage.completion_tokens ?? usage.outputTokens ?? null;
+      if (input != null || output != null) {
+        this.out.write(`${COLORS.faint(`  用量 ${input ?? '?'} in / ${output ?? '?'} out`)}\n`);
+      }
+    }
+    this.resume();
+  }
+}
+
+module.exports = { StreamRenderer, toolSummary, TOOL_TITLES, foldLine };