pi-zh-cn 0.1.0 → 0.2.0

package/README.md

@@ -1,58 +1,49 @@
 # pi-zh-cn
 
-pi（[@earendil-works/pi-coding-agent](https://github.com/earendil-works/pi)）简体中文 TUI 界面汉化插件。
-纯扩展 API 实现，不 patch 源码、不侵入安装；正常情况下可随 pi 升级保持兼容。
+把 [pi](https://github.com/earendil-works/pi) 编码代理的界面变成简体中文。装上重启即可，不想要了随时卸载。
 
-## 汉化范围
+原理上它只是一个普通扩展：调用官方扩展 API 替换文案，不打补丁、不改安装目录里的任何文件，所以 pi 正常升级后一般也能直接用。
 
-| 界面元素                                    | 方式                                                                                                   |
-| ------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
-| 启动 header（标题 + 快捷键提示行 + 引导语） | `ctx.ui.setHeader()`，快捷键跟随用户键位配置                                                           |
-| 流式加载提示（默认 "Working..."）           | `ctx.ui.setWorkingMessage()` → 「正在处理…」                                                           |
-| thinking 折叠块标签                         | `ctx.ui.setHiddenThinkingLabel()` → 「思考过程已折叠」                                                 |
-| 底部状态栏                                  | `ctx.ui.setFooter()` 中文重建：目录/分支/会话名、token/缓存/费用/上下文用量、模型/思考等级、扩展状态行 |
-| read 工具渲染                               | 同名重注册，标签「读取」+ 中文状态文案                                                                 |
-| bash 工具渲染                               | 同名重注册，标签「执行」+「完成 / 退出码 N / 输出过长已截断」                                          |
-| edit 工具渲染                               | 同名重注册，标签「编辑」+「已修改 / +N / -N」                                                          |
-| write 工具渲染                              | 同名重注册，标签「写入」+「已写入」                                                                    |
-| grep 工具渲染                               | 同名重注册，标签「搜索内容」+ 中文搜索结果状态                                                         |
-| find 工具渲染                               | 同名重注册，标签「查找文件」+ 中文查找结果状态                                                         |
-| ls 工具渲染                                 | 同名重注册，标签「列出目录」+ 中文目录状态                                                             |
-| PowerShell 工具渲染                         | 同名重注册，标签「执行 PowerShell」+ 中文执行状态                                                      |
+## 会变成中文的部分
 
-**明确不改**：工具 description（发给模型的内容保持英文，避免影响模型行为）、
-内置菜单及其他核心 chrome（扩展 API 覆盖不到，见下方“已知边界”）。
+- 启动画面：标题、快捷键提示、引导语（快捷键显示跟随你自己的键位配置）
+- 底部状态栏：当前目录 / 分支 / 会话名、token 与缓存用量、费用、上下文占比、模型和思考等级
+- 加载提示：「正在处理…」；thinking 折叠块的标签
+- 八个内置工具的执行结果：读取、执行（bash）、编辑、写入、搜索内容、查找文件、列出目录、PowerShell——状态行都是中文，比如「完成」「退出码 N」「输出过长已截断」
 
-运行时可用 `/footer` 在中文 footer 和 built-in footer 之间切换，方便核对统计数据。
+发给模型的内容不变。工具的 description 保持英文原文，避免影响模型行为。
 
-插件只替换 pi 已提供工具的渲染，不改变原有 active 工具集合；`grep`、`find`、`ls` 或 `powershell` 未启用时，不会因安装本插件而自动启用。
+## 保持原样的部分
 
-## 安装
+- 内置菜单和其他硬编码在 pi 源码里的英文（扩展 API 够不到，除非 fork 上游重编译，不值得）
+- 工具的启用范围：`grep`、`find`、`ls` 或 `powershell` 没开就不会被这个插件偷偷打开
 
-```bash
-# 本地路径安装（路径引用，不复制文件）
-pi install /path/to/pi-zh
+## 使用
 
-# 或发布 npm 后
+```bash
+# 从 npm 安装
 pi install npm:pi-zh-cn
 
-# 查看已安装包（remove 时使用这里显示的 source）
+# 查看/卸载用这里显示的 source 名
 pi list
 ```
 
-## 已知边界
+觉得中文状态栏不如原生好读，可以临时切回英文：
 
-- pi 无内置 i18n，内置菜单、`esc to …` 提示行等硬编码英文文案无法通过扩展 API 修改。
-  若需彻底汉化，需要 fork 上游或 patch `dist/bundle`（维护成本高，本插件不做）。
+```text
+/footer
+```
 
 ## 开发
 
 ```bash
-npm install          # 安装 devDependencies（含 peer 自动安装）
-npm exec tsc -p tsconfig.json   # 类型检查
+npm install
+./node_modules/.bin/tsc -p .   # 类型检查
 
 # 本地试跑
 pi --no-session -e ./extensions/index.ts -p "hi"
 ```
 
-文案集中在 [`extensions/i18n.ts`](extensions/i18n.ts)，改词只需动这一个文件。
+所有文案都集中在 [`extensions/zh.ts`](extensions/zh.ts)，想改词只动这一个文件就够了。
+
+改动记录见 [CHANGELOG.md](CHANGELOG.md)。pi 大版本升级后如果出现错位或残留英文，欢迎提 issue。

package/extensions/index.ts

@@ -6,6 +6,8 @@
  * - thinking 折叠块标签（setHiddenThinkingLabel）
  * - 启动 header（setHeader）
  * - 底部状态栏（setFooter）
+ * - 项目信任弹窗（project_trust handler + 中文 select）
+ * - 内置斜杠命令描述（addAutocompleteProvider 包一层翻译）
  * - 内置 read/bash/edit/write 工具的渲染文案（同名重注册，执行委托原实现）
  *
  * 不改动发给模型的内容（工具 description 保持英文）。
@@ -15,10 +17,6 @@ import type {
   BashToolDetails,
   EditToolDetails,
   ExtensionAPI,
-  FindToolDetails,
-  GrepToolDetails,
-  LsToolDetails,
-  PowerShellToolDetails,
   ReadToolDetails,
 } from "@earendil-works/pi-coding-agent";
 import {
@@ -38,11 +36,11 @@ import {
   VERSION,
 } from "@earendil-works/pi-coding-agent";
 import { homedir } from "node:os";
-import { readFileSync } from "node:fs";
-import { join, relative } from "node:path";
+import { readFileSync, realpathSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
 import type { AssistantMessage } from "@earendil-works/pi-ai";
 import { Text, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { zh } from "./i18n.ts";
+import { zh } from "./zh.ts";
 
 export default function (pi: ExtensionAPI) {
   let toggleFooter: (() => void) | undefined;
@@ -55,13 +53,84 @@ export default function (pi: ExtensionAPI) {
     },
   });
 
+  // ---------- 项目信任弹窗（中文选择器代替内置英文界面） ----------
+  // 复刻 ~/「agent dir」/trust.json 的祖先目录查找逻辑；已有决定的目录不再弹窗。
+  // 与内置的差异：「信任父文件夹」选项无法通过扩展 API 写入父目录决定，故省略。
+  const savedTrustDecision = (dir: string): boolean | null => {
+    let current = dir;
+    try {
+      current = realpathSync(current); // 与 core 的 normalizeCwd 一致
+    } catch {
+      // 目录不存在时保持原样
+    }
+    try {
+      const store = JSON.parse(readFileSync(join(getAgentDir(), "trust.json"), "utf8"));
+      for (;;) {
+        const decision = store[current];
+        if (typeof decision === "boolean") return decision;
+        const parent = dirname(current);
+        if (parent === current) return null;
+        current = parent;
+      }
+    } catch {
+      return null; // 无 trust.json 或内容无效 → 视作没有已存决定
+    }
+  };
+
+  pi.on("project_trust", async (event, ctx) => {
+    // 无 UI（rpc/print 等模式）或已有保存的决定时返回 undecided，让 core 走默认流程。
+    if (!ctx.hasUI || savedTrustDecision(event.cwd) !== null) return { trusted: "undecided" };
+
+    const options = [
+      zh.trust.options.trustAndRemember,
+      zh.trust.options.trustSessionOnly,
+      zh.trust.options.distrustAndRemember,
+      zh.trust.options.distrustSessionOnly,
+    ];
+    const selected = await ctx.ui.select(zh.trust.title(event.cwd), options);
+    switch (selected ?? zh.trust.options.distrustSessionOnly) {
+      case zh.trust.options.trustAndRemember:
+        return { trusted: "yes", remember: true };
+      case zh.trust.options.trustSessionOnly:
+        return { trusted: "yes" };
+      case zh.trust.options.distrustAndRemember:
+        return { trusted: "no", remember: true };
+      default:
+        return { trusted: "no" }; // 取消 = 本次不信任（与内置行为一致）
+    }
+  });
+
   // ---------- UI 文案 + 中文 header/footer（session 启动时应用） ----------
+  let autocompleteTranslated = false;
   pi.on("session_start", (_event, ctx) => {
     if (!ctx.hasUI) return;
 
     ctx.ui.setWorkingMessage(zh.workingMessage);
     ctx.ui.setHiddenThinkingLabel(zh.hiddenThinkingLabel);
 
+    // 中文化内置斜杠命令描述：包一层自动补全 provider，只替换命令项的
+    // description（文件补全等其他建议原样透传）。替换是幂等的，跨 session 只包一次。
+    if (ctx.mode === "tui" && !autocompleteTranslated) {
+      autocompleteTranslated = true;
+      ctx.ui.addAutocompleteProvider((current) => ({
+        ...(current.triggerCharacters ? { triggerCharacters: current.triggerCharacters } : {}),
+        getSuggestions: async (lines, cursorLine, cursorCol, options) => {
+          const suggestions = await current.getSuggestions(lines, cursorLine, cursorCol, options);
+          if (!suggestions) return null;
+          return {
+            ...suggestions,
+            items: suggestions.items.map((item) => {
+              const key = item.value.replace(/^\//, "") as keyof typeof zh.builtinCommands;
+              const zhDesc = zh.builtinCommands[key];
+              return zhDesc ? { ...item, description: zhDesc } : item;
+            }),
+          };
+        },
+        applyCompletion: (lines, cursorLine, cursorCol, item, prefix) =>
+          current.applyCompletion(lines, cursorLine, cursorCol, item, prefix),
+      }));
+    }
+
     // 中文 header：复刻内置结构（标题 + 折叠提示行 + 引导语），快捷键跟随用户键位配置。
     if (ctx.mode === "tui") {
       ctx.ui.setHeader((_tui, theme) => ({
@@ -77,8 +146,18 @@ export default function (pi: ExtensionAPI) {
             ),
             rawKeyHint("/", zh.header.commands),
             rawKeyHint("!", "bash"),
+            keyHint("app.tools.expand", zh.header.more),
           ].join(theme.fg("muted", " · "));
-          return [logo, compact, "", theme.fg("dim", zh.header.onboarding)];
+          return [
+            logo,
+            compact,
+            theme.fg(
+              "dim",
+              `${zh.header.expandHelp} (${keyText("app.tools.expand")})`,
+            ),
+            "",
+            theme.fg("dim", zh.header.onboarding),
+          ];
         },
         invalidate() {},
       }));
@@ -254,9 +333,6 @@ export default function (pi: ExtensionAPI) {
               const contextClause = `${zh.footer.ratioLabel}${pctText}/${fmt(windowSize)}${getAutoCompactSuffix()}`;
               const contextIndex = clauses.length;
               clauses.push(contextClause);
-              const xpIndex =
-                process.env.PI_EXPERIMENTAL === "1" ? clauses.length : -1;
-              if (xpIndex >= 0) clauses.push("xp");
 
               // 占比按阈值变色（>90% 红、>70% 黄）；实验标记沿用 built-in 样式。
               const statsLeft = clauses
@@ -268,9 +344,6 @@ export default function (pi: ExtensionAPI) {
                         ? theme.fg("warning", clause)
                         : theme.fg("dim", clause);
                   }
-                  if (index === xpIndex) {
-                    return `${theme.fg("dim", "•")} ${theme.bold(theme.fg("warning", "xp"))}`;
-                  }
                   return theme.fg("dim", clause);
                 })
                 .join(" ");
@@ -366,6 +439,137 @@ export default function (pi: ExtensionAPI) {
     registerLocalizedTools(ctx.cwd);
   });
 
+  // ---------- 工具渲染通用小工具 ----------
+  const textOf = (result: any): string =>
+    result.content?.[0]?.type === "text" ? result.content[0].text : "";
+
+  const countNonEmpty = (s: string): number =>
+    s.split("\n").filter((l) => l.trim()).length;
+
+  const notePartial = (msg: string, theme: any): Text =>
+    new Text(theme.fg("warning", msg), 0, 0);
+
+  // 错误结果：内容以 "Error" 开头时只展示首行（edit/write 共用）。
+  const errorFirstLine = (result: any, theme: any): Text | undefined => {
+    const out = textOf(result);
+    return out.startsWith("Error")
+      ? new Text(theme.fg("error", out.split("\n")[0]), 0, 0)
+      : undefined;
+  };
+
+  // 展开态：在摘要后追加逐行弱化的原始输出。
+  const withExpanded = (raw: string, summary: string, theme: any): string =>
+    raw
+      ? `${summary}\n${raw
+          .split("\n")
+          .map((l) => theme.fg("dim", l))
+          .join("\n")}`
+      : summary;
+
+  // 失败判定（bash/powershell 共用）：解析退出码；powershell 通过 extraRe
+  // 追加 Windows 平台提示的识别。
+  function failureState(output: string, extraRe: RegExp[] = []) {
+    const m = output.match(
+      /(?:exit code:\s*|command exited with code\s+)(\d+)/i,
+    );
+    const exitCode = m ? parseInt(m[1], 10) : null;
+    return {
+      exitCode,
+      failed:
+        exitCode !== null ||
+        /^error\b/i.test(output) ||
+        /\n\ncommand (?:timed out|was aborted|failed)/i.test(output) ||
+        extraRe.some((re) => re.test(output)),
+    };
+  }
+
+  // shell 类工具（bash/powershell 文案同构）的渲染对。
+  type ShellCopy =
+    | typeof zh.tools.bash
+    | typeof zh.tools.powershell;
+  const shellRenders = (w: ShellCopy, extraRe: RegExp[] = []) => ({
+    renderCall(args: any, theme: any): Text {
+      let text = theme.fg("toolTitle", theme.bold(w.title));
+      const cmd: string =
+        args.command.length > 80
+          ? `${args.command.slice(0, 77)}...`
+          : args.command;
+      text += theme.fg("accent", cmd);
+      if (args.timeout) text += theme.fg("dim", w.timeout(args.timeout));
+      return new Text(text, 0, 0);
+    },
+
+    renderResult(
+      result: any,
+      { expanded, isPartial }: { expanded: boolean; isPartial: boolean },
+      theme: any,
+    ): Text {
+      if (isPartial) return notePartial(w.running, theme);
+      const output = textOf(result);
+      const { exitCode, failed } = failureState(output, extraRe);
+      let text = failed
+        ? theme.fg(
+            "error",
+            exitCode !== null ? w.exit(exitCode) : w.failed,
+          )
+        : theme.fg("success", w.done);
+      text += theme.fg("dim", ` (${w.lines(countNonEmpty(output))})`);
+      if (
+        (result.details as BashToolDetails | undefined)?.truncation?.truncated
+      ) {
+        text += theme.fg("warning", ` ${w.truncated}`);
+      }
+      return new Text(withExpanded(expanded ? output : "", text, theme), 0, 0);
+    },
+  });
+
+  // 计数类工具（grep/find/ls 文案同构）的结果渲染：无匹配哨兵、条数统计、
+  // 上限提示与截断警告四处逻辑一致，仅文案不同。
+  function countResultRender(
+    labels: {
+      searching: string;
+      noMatch: string;
+      found: (n: number) => string;
+      limit?: (n: number) => string;
+      truncated: string;
+    },
+    sentinel: string,
+    limitField: string,
+  ) {
+    return (
+      result: any,
+      { expanded, isPartial }: { expanded: boolean; isPartial: boolean },
+      theme: any,
+    ): Text => {
+      if (isPartial) return notePartial(labels.searching, theme);
+      const details = result.details ?? {};
+      const output = textOf(result);
+      const isEmpty = output === sentinel;
+      let text = theme.fg(
+        isEmpty ? "muted" : "success",
+        isEmpty ? labels.noMatch : labels.found(countNonEmpty(output)),
+      );
+      if (labels.limit && typeof details[limitField] === "number") {
+        text += theme.fg("warning", labels.limit(details[limitField]));
+      }
+      // 与旧实现的行为差异：grep 原本同时检查 linesTruncated，find/ls 只查
+      // truncation.truncated；这里统一为两者都检查，Find/LsToolDetails 目前无
+      // linesTruncated 字段，运行时行为等价。若上游新增该字段需复核。
+      if (details.linesTruncated || details.truncation?.truncated) {
+        text += theme.fg("warning", labels.truncated);
+      }
+      return new Text(
+        withExpanded(
+          expanded ? (isEmpty ? labels.noMatch : output) : "",
+          text,
+          theme,
+        ),
+        0,
+        0,
+      );
+    };
+  }
+
   function registerLocalizedTools(cwd: string) {
     const activeTools = pi.getActiveTools();
     const builtinTools = new Set(
@@ -377,12 +581,11 @@ export default function (pi: ExtensionAPI) {
 
     // ---------- 内置工具汉化渲染 ----------
     // read
-    const originalRead = createReadTool(cwd);
     pi.registerTool({
-      ...originalRead,
+      ...createReadTool(cwd),
       label: zh.tools.read.label,
 
-      renderCall(args: any, theme: any, _context: any) {
+      renderCall(args: any, theme: any) {
         let text = theme.fg("toolTitle", theme.bold(`${zh.tools.read.title} `));
         text += theme.fg("accent", args.path);
         if (args.offset || args.limit) {
@@ -398,14 +601,10 @@ export default function (pi: ExtensionAPI) {
         result: any,
         { expanded, isPartial }: { expanded: boolean; isPartial: boolean },
         theme: any,
-        _context: any,
       ) {
-        if (isPartial)
-          return new Text(theme.fg("warning", zh.tools.read.reading), 0, 0);
+        if (isPartial) return notePartial(zh.tools.read.reading, theme);
 
-        const details = result.details as ReadToolDetails | undefined;
         const content = result.content[0];
-
         if (content?.type === "image") {
           return new Text(theme.fg("success", zh.tools.read.imageLoaded), 0, 0);
         }
@@ -413,103 +612,40 @@ export default function (pi: ExtensionAPI) {
           return new Text(theme.fg("error", zh.tools.read.noContent), 0, 0);
         }
 
-        const lineCount = content.text.split("\n").length;
-        let text = theme.fg("success", zh.tools.read.lines(lineCount));
-
-        if (details?.truncation?.truncated) {
+        let text = theme.fg(
+          "success",
+          zh.tools.read.lines(content.text.split("\n").length),
+        );
+        const truncation = (result.details as ReadToolDetails | undefined)
+          ?.truncation;
+        if (truncation?.truncated) {
           text += theme.fg(
             "warning",
-            zh.tools.read.truncatedFrom(details.truncation.totalLines),
+            zh.tools.read.truncatedFrom(truncation.totalLines),
           );
         }
-
-        if (expanded) {
-          for (const line of content.text.split("\n")) {
-            text += `\n${theme.fg("dim", line)}`;
-          }
-        }
-
-        return new Text(text, 0, 0);
+        return new Text(
+          withExpanded(expanded ? content.text : "", text, theme),
+          0,
+          0,
+        );
       },
     });
 
-    // bash
-    const originalBash = createBashTool(cwd);
+    // bash / powershell（渲染逻辑同构，仅文案与失败判定集合不同）
     pi.registerTool({
-      ...originalBash,
+      ...createBashTool(cwd),
       label: zh.tools.bash.label,
-
-      renderCall(args: any, theme: any, _context: any) {
-        let text = theme.fg("toolTitle", theme.bold(zh.tools.bash.title));
-        const cmd: string =
-          args.command.length > 80
-            ? `${args.command.slice(0, 77)}...`
-            : args.command;
-        text += theme.fg("accent", cmd);
-        if (args.timeout) {
-          text += theme.fg("dim", zh.tools.bash.timeout(args.timeout));
-        }
-        return new Text(text, 0, 0);
-      },
-
-      renderResult(
-        result: any,
-        { expanded, isPartial }: { expanded: boolean; isPartial: boolean },
-        theme: any,
-        _context: any,
-      ) {
-        if (isPartial)
-          return new Text(theme.fg("warning", zh.tools.bash.running), 0, 0);
-
-        const details = result.details as BashToolDetails | undefined;
-        const content = result.content[0];
-        const output: string = content?.type === "text" ? content.text : "";
-
-        const exitMatch = output.match(
-          /(?:exit code:\s*|command exited with code\s+)(\d+)/i,
-        );
-        const exitCode = exitMatch ? parseInt(exitMatch[1], 10) : null;
-        const failed =
-          exitCode !== null ||
-          /^error\b/i.test(output) ||
-          /\n\ncommand (?:timed out|was aborted|failed)/i.test(output);
-        const lineCount = output.split("\n").filter((l) => l.trim()).length;
-
-        let text = "";
-        if (!failed) {
-          text += theme.fg("success", zh.tools.bash.done);
-        } else {
-          text += theme.fg(
-            "error",
-            exitCode !== null
-              ? zh.tools.bash.exit(exitCode)
-              : zh.tools.bash.failed,
-          );
-        }
-        text += theme.fg("dim", ` (${zh.tools.bash.lines(lineCount)})`);
-
-        if (details?.truncation?.truncated) {
-          text += theme.fg("warning", ` ${zh.tools.bash.truncated}`);
-        }
-
-        if (expanded) {
-          for (const line of output.split("\n")) {
-            text += `\n${theme.fg("dim", line)}`;
-          }
-        }
-
-        return new Text(text, 0, 0);
-      },
+      ...shellRenders(zh.tools.bash),
     });
 
     // edit
-    const originalEdit = createEditTool(cwd);
     pi.registerTool({
-      ...originalEdit,
+      ...createEditTool(cwd),
       label: zh.tools.edit.label,
       renderShell: "self",
 
-      renderCall(args: any, theme: any, _context: any) {
+      renderCall(args: any, theme: any) {
         let text = theme.fg("toolTitle", theme.bold(zh.tools.edit.title));
         text += theme.fg("accent", args.path);
         return new Text(text, 0, 0);
@@ -519,25 +655,20 @@ export default function (pi: ExtensionAPI) {
         result: any,
         { expanded, isPartial }: { expanded: boolean; isPartial: boolean },
         theme: any,
-        _context: any,
       ) {
-        if (isPartial)
-          return new Text(theme.fg("warning", zh.tools.edit.editing), 0, 0);
+        if (isPartial) return notePartial(zh.tools.edit.editing, theme);
 
-        const details = result.details as EditToolDetails | undefined;
-        const content = result.content[0];
+        const err = errorFirstLine(result, theme);
+        if (err) return err;
 
-        if (content?.type === "text" && content.text.startsWith("Error")) {
-          return new Text(theme.fg("error", content.text.split("\n")[0]), 0, 0);
-        }
+        const details = result.details as EditToolDetails | undefined;
         if (!details?.diff) {
           return new Text(theme.fg("success", zh.tools.edit.applied), 0, 0);
         }
 
-        const diffLines: string[] = details.diff.split("\n");
         let additions = 0,
           removals = 0;
-        for (const line of diffLines) {
+        for (const line of details.diff.split("\n")) {
           if (line.startsWith("+") && !line.startsWith("+++")) additions++;
           if (line.startsWith("-") && !line.startsWith("---")) removals++;
         }
@@ -546,23 +677,20 @@ export default function (pi: ExtensionAPI) {
         text += theme.fg("dim", " / ");
         text += theme.fg("error", zh.tools.edit.removals(removals));
 
-        if (expanded) {
-          for (const line of diffLines) {
-            text += `\n${theme.fg("dim", line)}`;
-          }
-        }
-
-        return new Text(text, 0, 0);
+        return new Text(
+          withExpanded(expanded ? details.diff : "", text, theme),
+          0,
+          0,
+        );
       },
     });
 
     // write
-    const originalWrite = createWriteTool(cwd);
     pi.registerTool({
-      ...originalWrite,
+      ...createWriteTool(cwd),
       label: zh.tools.write.label,
 
-      renderCall(args: any, theme: any, _context: any) {
+      renderCall(args: any, theme: any) {
         let text = theme.fg("toolTitle", theme.bold(zh.tools.write.title));
         text += theme.fg("accent", args.path);
         const lineCount = String(args.content).split("\n").length;
@@ -570,31 +698,21 @@ export default function (pi: ExtensionAPI) {
         return new Text(text, 0, 0);
       },
 
-      renderResult(
-        result: any,
-        { isPartial }: { isPartial: boolean },
-        theme: any,
-        _context: any,
-      ) {
-        if (isPartial)
-          return new Text(theme.fg("warning", zh.tools.write.writing), 0, 0);
-
-        const content = result.content[0];
-        if (content?.type === "text" && content.text.startsWith("Error")) {
-          return new Text(theme.fg("error", content.text.split("\n")[0]), 0, 0);
-        }
-
+      renderResult(result: any, { isPartial }: { isPartial: boolean }, theme: any) {
+        if (isPartial) return notePartial(zh.tools.write.writing, theme);
+        const err = errorFirstLine(result, theme);
+        if (err) return err;
         return new Text(theme.fg("success", zh.tools.write.written), 0, 0);
       },
     });
 
+    // grep / find / ls：调用渲染各自略有差异，结果渲染走同一个计数模板。
     if (builtinTools.has("grep")) {
-      const originalGrep = createGrepTool(cwd);
       pi.registerTool({
-        ...originalGrep,
+        ...createGrepTool(cwd),
         label: zh.tools.grep.label,
 
-        renderCall(args: any, theme: any, _context: any) {
+        renderCall(args: any, theme: any) {
           let text = theme.fg("toolTitle", theme.bold(zh.tools.grep.title));
           text += theme.fg("accent", args.pattern);
           if (args.path) text += theme.fg("dim", ` · ${args.path}`);
@@ -602,214 +720,76 @@ export default function (pi: ExtensionAPI) {
           return new Text(text, 0, 0);
         },
 
-        renderResult(
-          result: any,
-          { expanded, isPartial }: { expanded: boolean; isPartial: boolean },
-          theme: any,
-          _context: any,
-        ) {
-          if (isPartial)
-            return new Text(theme.fg("warning", zh.tools.grep.searching), 0, 0);
-
-          const details = result.details as GrepToolDetails | undefined;
-          const content = result.content[0];
-          const output = content?.type === "text" ? content.text : "";
-          const noMatches = output === "No matches found";
-          const count = output
-            .split("\n")
-            .filter((line: string) => line.trim()).length;
-          let text = theme.fg(
-            noMatches ? "muted" : "success",
-            noMatches ? zh.tools.grep.noMatches : zh.tools.grep.matches(count),
-          );
-          if (details?.matchLimitReached !== undefined) {
-            text += theme.fg(
-              "warning",
-              zh.tools.grep.matchLimit(details.matchLimitReached),
-            );
-          }
-          if (details?.linesTruncated || details?.truncation?.truncated) {
-            text += theme.fg("warning", zh.tools.grep.truncated);
-          }
-          if (expanded && output) {
-            const expandedOutput = noMatches ? zh.tools.grep.noMatches : output;
-            text += `\n${theme.fg("dim", expandedOutput)}`;
-          }
-          return new Text(text, 0, 0);
-        },
+        renderResult: countResultRender(
+          {
+            searching: zh.tools.grep.searching,
+            noMatch: zh.tools.grep.noMatches,
+            found: zh.tools.grep.matches,
+            limit: zh.tools.grep.matchLimit,
+            truncated: zh.tools.grep.truncated,
+          },
+          "No matches found",
+          "matchLimitReached",
+        ),
       });
     }
 
     if (builtinTools.has("find")) {
-      const originalFind = createFindTool(cwd);
       pi.registerTool({
-        ...originalFind,
+        ...createFindTool(cwd),
         label: zh.tools.find.label,
 
-        renderCall(args: any, theme: any, _context: any) {
+        renderCall(args: any, theme: any) {
           let text = theme.fg("toolTitle", theme.bold(zh.tools.find.title));
           text += theme.fg("accent", args.pattern);
           if (args.path) text += theme.fg("dim", ` · ${args.path}`);
           return new Text(text, 0, 0);
         },
 
-        renderResult(
-          result: any,
-          { expanded, isPartial }: { expanded: boolean; isPartial: boolean },
-          theme: any,
-          _context: any,
-        ) {
-          if (isPartial)
-            return new Text(theme.fg("warning", zh.tools.find.searching), 0, 0);
-
-          const details = result.details as FindToolDetails | undefined;
-          const content = result.content[0];
-          const output = content?.type === "text" ? content.text : "";
-          const noFiles = output === "No files found matching pattern";
-          const count = output
-            .split("\n")
-            .filter((line: string) => line.trim()).length;
-          let text = theme.fg(
-            noFiles ? "muted" : "success",
-            noFiles ? zh.tools.find.noFiles : zh.tools.find.results(count),
-          );
-          if (details?.resultLimitReached !== undefined) {
-            text += theme.fg(
-              "warning",
-              zh.tools.find.resultLimit(details.resultLimitReached),
-            );
-          }
-          if (details?.truncation?.truncated) {
-            text += theme.fg("warning", zh.tools.grep.truncated);
-          }
-          if (expanded && output) {
-            const expandedOutput = noFiles ? zh.tools.find.noFiles : output;
-            text += `\n${theme.fg("dim", expandedOutput)}`;
-          }
-          return new Text(text, 0, 0);
-        },
+        renderResult: countResultRender(
+          {
+            searching: zh.tools.find.searching,
+            noMatch: zh.tools.find.noFiles,
+            found: zh.tools.find.results,
+            limit: zh.tools.find.resultLimit,
+            truncated: zh.tools.grep.truncated,
+          },
+          "No files found matching pattern",
+          "resultLimitReached",
+        ),
       });
     }
 
     if (builtinTools.has("ls")) {
-      const originalLs = createLsTool(cwd);
       pi.registerTool({
-        ...originalLs,
+        ...createLsTool(cwd),
         label: zh.tools.ls.label,
 
-        renderCall(args: any, theme: any, _context: any) {
+        renderCall(args: any, theme: any) {
           let text = theme.fg("toolTitle", theme.bold(zh.tools.ls.title));
           text += theme.fg("accent", args.path || ".");
           return new Text(text, 0, 0);
         },
 
-        renderResult(
-          result: any,
-          { expanded, isPartial }: { expanded: boolean; isPartial: boolean },
-          theme: any,
-          _context: any,
-        ) {
-          if (isPartial)
-            return new Text(theme.fg("warning", zh.tools.ls.listing), 0, 0);
-
-          const details = result.details as LsToolDetails | undefined;
-          const content = result.content[0];
-          const output = content?.type === "text" ? content.text : "";
-          const empty = output === "(empty directory)";
-          const count = output
-            .split("\n")
-            .filter((line: string) => line.trim()).length;
-          let text = theme.fg(
-            empty ? "muted" : "success",
-            empty ? zh.tools.ls.empty : zh.tools.ls.entries(count),
-          );
-          if (details?.entryLimitReached !== undefined) {
-            text += theme.fg(
-              "warning",
-              zh.tools.ls.entryLimit(details.entryLimitReached),
-            );
-          }
-          if (details?.truncation?.truncated) {
-            text += theme.fg("warning", zh.tools.grep.truncated);
-          }
-          if (expanded && output) {
-            const expandedOutput = empty ? zh.tools.ls.empty : output;
-            text += `\n${theme.fg("dim", expandedOutput)}`;
-          }
-          return new Text(text, 0, 0);
-        },
+        renderResult: countResultRender(
+          {
+            searching: zh.tools.ls.listing,
+            noMatch: zh.tools.ls.empty,
+            found: zh.tools.ls.entries,
+            limit: zh.tools.ls.entryLimit,
+            truncated: zh.tools.grep.truncated,
+          },
+          "(empty directory)",
+          "entryLimitReached",
+        ),
       });
     }
 
     if (builtinTools.has("powershell")) {
-      const originalPowerShell = createPowerShellTool(cwd);
       pi.registerTool({
-        ...originalPowerShell,
+        ...createPowerShellTool(cwd),
         label: zh.tools.powershell.label,
-
-        renderCall(args: any, theme: any, _context: any) {
-          let text = theme.fg(
-            "toolTitle",
-            theme.bold(zh.tools.powershell.title),
-          );
-          const command =
-            args.command.length > 80
-              ? `${args.command.slice(0, 77)}...`
-              : args.command;
-          text += theme.fg("accent", command);
-          if (args.timeout) {
-            text += theme.fg("dim", zh.tools.powershell.timeout(args.timeout));
-          }
-          return new Text(text, 0, 0);
-        },
-
-        renderResult(
-          result: any,
-          { expanded, isPartial }: { expanded: boolean; isPartial: boolean },
-          theme: any,
-          _context: any,
-        ) {
-          if (isPartial)
-            return new Text(
-              theme.fg("warning", zh.tools.powershell.running),
-              0,
-              0,
-            );
-
-          const details = result.details as PowerShellToolDetails | undefined;
-          const content = result.content[0];
-          const output = content?.type === "text" ? content.text : "";
-          const exitMatch = output.match(
-            /(?:exit code:\s*|command exited with code\s+)(\d+)/i,
-          );
-          const exitCode = exitMatch ? parseInt(exitMatch[1], 10) : null;
-          const failed =
-            exitCode !== null ||
-            /^error\b/i.test(output) ||
-            /only available on windows/i.test(output) ||
-            /\n\ncommand (?:timed out|was aborted|failed)/i.test(output);
-          const lineCount = output
-            .split("\n")
-            .filter((line: string) => line.trim()).length;
-          let text = theme.fg(
-            failed ? "error" : "success",
-            failed
-              ? exitCode !== null
-                ? zh.tools.powershell.exit(exitCode)
-                : zh.tools.powershell.failed
-              : zh.tools.powershell.done,
-          );
-          text += theme.fg("dim", ` (${zh.tools.powershell.lines(lineCount)})`);
-          if (details?.truncation?.truncated) {
-            text += theme.fg("warning", ` ${zh.tools.powershell.truncated}`);
-          }
-          if (expanded) {
-            for (const line of output.split("\n")) {
-              text += `\n${theme.fg("dim", line)}`;
-            }
-          }
-          return new Text(text, 0, 0);
-        },
+        ...shellRenders(zh.tools.powershell, [/only available on windows/i]),
       });
     }
 

package/extensions/{i18n.ts → zh.ts}

@@ -44,6 +44,8 @@ export const zh = {
     interrupt: "中断",
     clearExit: "清空/退出",
     commands: "命令菜单",
+    more: "更多",
+    expandHelp: "按下上述按键查看完整启动帮助与已加载资源",
     onboarding:
       "Pi 能解释自身的功能、查阅自己的文档——想知道怎么用、怎么扩展，直接问它。",
   },
@@ -122,6 +124,45 @@ export const zh = {
       truncated: "[输出过长，已截断]",
     },
   },
+
+  // 项目信任弹窗（复刻内置“信任/不信任”选项；“信任父文件夹”变体不支持）
+  trust: {
+    title: (cwd: string) =>
+      `是否信任项目目录：${cwd}？将允许 pi 加载项目配置并执行项目扩展`,
+    options: {
+      trustAndRemember: "信任并记住此决定",
+      trustSessionOnly: "仅本次会话信任",
+      distrustAndRemember: "不信任并记住此决定",
+      distrustSessionOnly: "本次会话不信任",
+    },
+  },
+
+  // 内置斜杠命令的中文描述（key 为命令名；带参数提示的条目已按 core 的
+  // `hint — description` 合成格式写好，避免运行时拼字符串）
+  builtinCommands: {
+    settings: "打开设置菜单",
+    model: "<provider/model> — 选择模型（打开选择器界面）",
+    tree: "浏览会话树（切换分支）",
+    thinking: "<level> — 设置思考等级",
+    "scoped-models": "启用/停用 Ctrl+P 轮换用的模型",
+    export: "导出会话（默认 HTML，可指定 .html/.jsonl 路径）",
+    import: "从 JSONL 文件导入并恢复会话",
+    share: "通过 GitHub 私密 gist 分享会话",
+    copy: "复制最后一条助手消息到剪贴板",
+    name: "设置会话显示名称",
+    session: "显示会话信息与统计",
+    changelog: "显示更新日志",
+    hotkeys: "显示全部快捷键",
+    fork: "从历史用户消息创建新分叉",
+    clone: "在当前位置复制当前会话",
+    trust: "保存项目信任决定以便后续会话使用",
+    login: "<provider> — 配置提供商认证",
+    logout: "移除提供商认证",
+    new: "开始新会话",
+    compact: "手动压缩会话上下文",
+    resume: "恢复另一个会话",
+    reload: "重新加载快捷键、扩展、技能、提示词、主题和上下文文件",
+    quit: "退出 pi",
+  },
 } as const;
 
-export type Zh = typeof zh;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-zh-cn",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "pi 编码代理的简体中文界面汉化插件",
   "type": "module",
   "keywords": [
@@ -23,6 +23,6 @@
   },
   "devDependencies": {
     "@types/node": "^26.3.0",
-    "typescript": "^7.0.2"
+    "typescript": "^5.9.3"
   }
 }