@clapecho233/pi-smart-fold 0.1.0

package/README.md

@@ -0,0 +1,64 @@
+# pi-smart-fold
+
+[pi](https://github.com/earendil-works/pi-mono) coding-agent 插件：保持会话记录紧凑。
+
+- **工具输出默认折叠** — 每次 `session_start`（启动 / `/reload` / `/new` / `/resume` / `/fork`）自动调用 `ctx.ui.setToolsExpanded(false)`，工具输出保持折叠，需要时用 `ctrl+o` 手动展开。
+- **Thinking 折叠为单行、默认滚动显示最后一行** — 通过 pi 的 markdown transformer（`messageType: "assistant-thinking"`）把每个思考块折叠成一行，只显示**最后一行**内容；流式输出时该行随最新内容持续刷新，效果如同 `tail -f`。
+  - 截断按**终端显示宽度**计算（中文/emoji 等宽字符占 2 列），超宽时保留行尾并加 `…` 前缀。
+  - 折叠仅影响 TUI 显示，不改动会话文件与发送给模型的上下文。
+
+## 使用
+
+```text
+/fold                  查看当前状态
+/fold thinking on|off  开关 thinking 折叠（持久化到 smart-fold.config.json）
+/fold tools on|off     开关启动时工具输出折叠（立即作用于当前会话，并持久化）
+```
+
+配置文件 `smart-fold.config.json`（位于插件目录，可手工编辑）：
+
+```json
+{
+  "toolsFold": true,
+  "thinkingFold": true
+}
+```
+
+## 安装
+
+任选其一：
+
+```bash
+# 方式 A：作为目录插件放入全局自动发现路径
+git clone <this-repo> ~/.pi/agent/extensions/smart-fold
+
+# 方式 B：通过 pi 包管理安装
+pi install git:<repo-url>
+
+# 方式 C：加入 settings.json
+# ~/.pi/agent/settings.json → { "extensions": ["/path/to/pi-smart-fold"] }
+
+# 临时测试
+pi -e /path/to/pi-smart-fold/index.ts
+```
+
+> 插件无任何 npm 依赖，pi 通过 jiti 直接加载 TypeScript。
+
+## 开发
+
+```bash
+npm test   # 纯函数单元测试（Node ≥ 22.18 原生 TS 类型剥离，无需构建）
+```
+
+结构：
+
+```
+index.ts          插件入口（事件 / transformer / /fold 命令）
+lib/fold.ts       纯函数：显示宽度、行尾截断、思考折叠（无依赖、可单测）
+lib/config.ts     配置读写（缺失/损坏时回退默认值）
+test/fold.test.mjs 单元测试
+```
+
+## 兼容性
+
+基于 pi `0.85.1` 的公开扩展 API（`registerMarkdownTransformer`、`ctx.ui.setToolsExpanded`、`registerCommand`）。

package/index.ts

@@ -0,0 +1,154 @@
+/**
+ * pi-smart-fold
+ * =============
+ * A pi (https://github.com/earendil-works/pi-mono) coding-agent extension that
+ * keeps the transcript compact:
+ *
+ *   1. Tool output is collapsed on every session start (`session_start` covers
+ *      startup, /reload, /new, /resume and /fork).
+ *   2. Every assistant *thinking* block is folded down to a single line that
+ *      shows its LAST line. While the model streams, the folded line keeps
+ *      updating to the newest text — an auto-scrolling "tail -f" effect.
+ *
+ * The full thinking text is never modified on disk or in the LLM context:
+ * folding is display-only, applied through pi's markdown-transformer hook.
+ *
+ * Runtime control:
+ *   /fold                  show current state
+ *   /fold thinking on|off  fold / unfold thinking blocks (persisted)
+ *   /fold tools on|off     collapse / expand tool output (persisted, and
+ *                          applied to the current session immediately)
+ *
+ * Config file: `smart-fold.config.json` next to this entry file.
+ */
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { collapseThinking } from "./lib/fold.ts";
+import { loadConfig, saveConfig, type SmartFoldConfig } from "./lib/config.ts";
+
+/** Best-effort resolve of this extension's directory (for the config file). */
+function resolveExtensionDir(): string | undefined {
+  try {
+    // jiti (pi's TS loader) shims import.meta.url for extension modules.
+    const url = import.meta.url;
+    if (typeof url === "string" && url.startsWith("file:")) {
+      return dirname(fileURLToPath(url));
+    }
+  } catch {
+    // fall through
+  }
+  try {
+    // jiti CJS interop fallback
+    if (typeof __filename === "string") return dirname(__filename);
+  } catch {
+    // ignore
+  }
+  return undefined;
+}
+
+export default function smartFold(pi: ExtensionAPI): void {
+  const extensionDir = resolveExtensionDir();
+  const config: SmartFoldConfig = extensionDir ? loadConfig(extensionDir) : { toolsFold: true, thinkingFold: true };
+
+  // Runtime state (starts from persisted config; /fold mutates + persists).
+  let thinkingFold = config.thinkingFold;
+
+  // -------------------------------------------------------------------------
+  // 1) Fold thinking blocks to their last line (display-only).
+  // -------------------------------------------------------------------------
+  // The transformer runs whenever an assistant message (re)renders — including
+  // every streaming update — so the folded line automatically "scrolls" to the
+  // latest thinking text while the model works.
+  pi.registerMarkdownTransformer((markdown, context) => {
+    if (context.messageType !== "assistant-thinking") return markdown;
+    if (!thinkingFold) return markdown;
+    // -1 gives the renderer a little slack for padding/borders; collapseThinking
+    // sanitizes the width itself.
+    return collapseThinking(markdown, context.availableWidth - 1);
+  });
+
+  // -------------------------------------------------------------------------
+  // 2) Collapse tool output on session start.
+  // -------------------------------------------------------------------------
+  pi.on("session_start", async (_event, ctx) => {
+    if (!config.toolsFold) return;
+    if (!ctx.hasUI) return; // no-op guard for print / json modes
+    try {
+      ctx.ui.setToolsExpanded(false);
+    } catch {
+      // Never let folding break a session start.
+    }
+  });
+
+  // -------------------------------------------------------------------------
+  // 3) /fold command — inspect and toggle at runtime.
+  // -------------------------------------------------------------------------
+  const persist = (next: SmartFoldConfig): void => {
+    if (extensionDir) saveConfig(extensionDir, next);
+  };
+
+  const statusLine = (): string =>
+    `smart-fold — thinking: ${thinkingFold ? "折叠(folded)" : "展开(full)"} · 工具输出: ${
+      config.toolsFold ? "启动时折叠(collapsed)" : "启动时展开(expanded)"
+    }`;
+
+  pi.registerCommand("fold", {
+    description: "smart-fold: 查看/切换 thinking 折叠与工具输出折叠 (on|off)",
+    handler: async (args, ctx) => {
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      const target = parts[0]?.toLowerCase();
+      const value = parts[1]?.toLowerCase();
+
+      if (target === "thinking") {
+        if (value !== "on" && value !== "off") {
+          ctx.ui.notify("用法: /fold thinking on|off", "warning");
+          return;
+        }
+        thinkingFold = value === "on";
+        config.thinkingFold = thinkingFold;
+        persist(config);
+        if (ctx.mode === "tui") {
+          try {
+            // Force every rendered assistant message to rebuild through the
+            // markdown transformer so the toggle applies to history too.
+            // (Resets a custom hidden-thinking label to its default, if any.)
+            ctx.ui.setHiddenThinkingLabel();
+          } catch {
+            // New content still picks the change up on next render.
+          }
+        }
+        ctx.ui.notify(`thinking: ${thinkingFold ? "折叠(folded)" : "展开(full)"} — 已保存`, "info");
+        return;
+      }
+
+      if (target === "tools") {
+        if (value !== "on" && value !== "off") {
+          ctx.ui.notify("用法: /fold tools on|off", "warning");
+          return;
+        }
+        config.toolsFold = value === "on";
+        persist(config);
+        if (ctx.hasUI) {
+          try {
+            ctx.ui.setToolsExpanded(!config.toolsFold); // on => collapsed
+          } catch {
+            // Applied on next session_start anyway.
+          }
+        }
+        ctx.ui.notify(
+          `工具输出: ${config.toolsFold ? "折叠(collapsed)" : "展开(expanded)"} — 已保存`,
+          "info",
+        );
+        return;
+      }
+
+      if (target !== undefined) {
+        ctx.ui.notify("用法: /fold [thinking|tools] [on|off]", "warning");
+        return;
+      }
+
+      ctx.ui.notify(statusLine(), "info");
+    },
+  });
+}

package/lib/config.ts

@@ -0,0 +1,51 @@
+/**
+ * pi-smart-fold — config persistence.
+ *
+ * The config lives next to the extension entry (`smart-fold.config.json`).
+ * Every read/write is best-effort: a missing or broken file simply falls
+ * back to defaults instead of breaking pi startup.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export interface SmartFoldConfig {
+  /** Collapse tool output at every session start. Default: true */
+  toolsFold: boolean;
+  /** Fold each thinking block down to its (live) last line. Default: true */
+  thinkingFold: boolean;
+}
+
+export const defaultConfig: SmartFoldConfig = {
+  toolsFold: true,
+  thinkingFold: true,
+};
+
+export function configFilePath(extensionDir: string): string {
+  return join(extensionDir, "smart-fold.config.json");
+}
+
+/** Load config merged over defaults; never throws. */
+export function loadConfig(extensionDir: string): SmartFoldConfig {
+  try {
+    const file = configFilePath(extensionDir);
+    if (!existsSync(file)) return { ...defaultConfig };
+    const parsed = JSON.parse(readFileSync(file, "utf8")) as Partial<SmartFoldConfig>;
+    return {
+      toolsFold: typeof parsed.toolsFold === "boolean" ? parsed.toolsFold : defaultConfig.toolsFold,
+      thinkingFold:
+        typeof parsed.thinkingFold === "boolean" ? parsed.thinkingFold : defaultConfig.thinkingFold,
+    };
+  } catch {
+    return { ...defaultConfig };
+  }
+}
+
+/** Persist config best-effort. Returns true on success. */
+export function saveConfig(extensionDir: string, config: SmartFoldConfig): boolean {
+  try {
+    writeFileSync(configFilePath(extensionDir), JSON.stringify(config, null, 2) + "\n", "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}

package/lib/fold.ts

@@ -0,0 +1,133 @@
+/**
+ * pi-smart-fold — pure folding helpers.
+ *
+ * No pi imports here: this module stays dependency-free and unit-testable
+ * with plain `node` (Node >= 23 type stripping; no build step needed).
+ */
+
+/** Regex for CSI / OSC escape sequences — ignored when measuring width. */
+const ANSI_PATTERN =
+  /(?:\u001b\[[0-9;?]*[A-Za-z])|(?:\u001b\][^\u0007]*(?:\u0007|\u001b\\))/g;
+
+/**
+ * Display width of a single code point.
+ * East Asian wide/fullwidth characters and emoji count as 2 columns,
+ * combining marks and zero-width characters count as 0.
+ * Best-effort approximation — good enough for one-line truncation.
+ */
+export function codePointWidth(cp: number): number {
+  // Zero-width: combining diacritics, ZWSP, BOM, variation selectors
+  if (
+    cp === 0x200b ||
+    cp === 0xfeff ||
+    (cp >= 0x0300 && cp <= 0x036f) ||
+    (cp >= 0x20d0 && cp <= 0x20ff) ||
+    (cp >= 0xfe00 && cp <= 0xfe0f)
+  ) {
+    return 0;
+  }
+  // Wide: Hangul Jamo, CJK radicals/symbols, kana, Yi, Hangul syllables,
+  // CJK ideographs (incl. ext A/B+), compat ideographs/forms, fullwidth forms,
+  // common emoji planes
+  if (
+    (cp >= 0x1100 && cp <= 0x115f) ||
+    (cp >= 0x2e80 && cp <= 0x303e) ||
+    (cp >= 0x3041 && cp <= 0x33ff) ||
+    (cp >= 0x3400 && cp <= 0x4dbf) ||
+    (cp >= 0x4e00 && cp <= 0x9fff) ||
+    (cp >= 0xa000 && cp <= 0xa4cf) ||
+    (cp >= 0xac00 && cp <= 0xd7a3) ||
+    (cp >= 0xf900 && cp <= 0xfaff) ||
+    (cp >= 0xfe30 && cp <= 0xfe4f) ||
+    (cp >= 0xff00 && cp <= 0xff60) ||
+    (cp >= 0xffe0 && cp <= 0xffe6) ||
+    (cp >= 0x1f300 && cp <= 0x1f64f) ||
+    (cp >= 0x1f680 && cp <= 0x1f6ff) ||
+    (cp >= 0x1f900 && cp <= 0x1f9ff) ||
+    (cp >= 0x1fa70 && cp <= 0x1faff) ||
+    (cp >= 0x20000 && cp <= 0x3fffd)
+  ) {
+    return 2;
+  }
+  return 1;
+}
+
+/** Terminal display width of a string, in columns (ANSI escapes ignored). */
+export function displayWidth(input: string): number {
+  let width = 0;
+  for (const ch of input.replace(ANSI_PATTERN, "")) {
+    width += codePointWidth(ch.codePointAt(0) ?? 0);
+  }
+  return width;
+}
+
+/**
+ * Keep only the tail of `input` that fits within `maxWidth` display columns.
+ * When content is cut, an ellipsis `…` is prefixed (reserving 1 column).
+ */
+export function tailFit(input: string, maxWidth: number): string {
+  if (!Number.isFinite(maxWidth)) return input;
+  if (maxWidth < 1) return "";
+  if (displayWidth(input) <= maxWidth) return input;
+
+  const budget = maxWidth - 1; // reserve one column for the ellipsis
+  if (budget < 1) return "…";
+
+  const chars = Array.from(input);
+  let used = 0;
+  let start = chars.length;
+  for (let i = chars.length - 1; i >= 0; i--) {
+    const w = codePointWidth(chars[i].codePointAt(0) ?? 0);
+    if (used + w > budget) break;
+    used += w;
+    start = i;
+  }
+  return "…" + chars.slice(start).join("");
+}
+
+/** Last line of a markdown string whose trimmed content is non-empty. */
+export function lastNonEmptyLine(markdown: string): string {
+  const lines = markdown.split(/\r?\n/);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].trim() !== "") return lines[i];
+  }
+  return "";
+}
+
+/**
+ * Strip common block-level markdown markers (`#`, `>`, `-`, `*`, `1.`)
+ * so the collapsed line reads like prose. Runs a few passes for nesting
+ * like `> - item`. Code fence markers are removed since they cannot
+ * render usefully on a single collapsed line.
+ */
+export function stripBlockMarkers(raw: string): string {
+  let line = raw.trim();
+  for (let pass = 0; pass < 3; pass++) {
+    const next = line
+      .replace(/^#{1,6}\s+/, "")
+      .replace(/^>\s+/, "")
+      .replace(/^[-*+]\s+/, "")
+      .replace(/^\d{1,9}[.)]\s+/, "");
+    if (next === line) break;
+    line = next;
+  }
+  line = line.replace(/`{3,}/g, "");
+  return line.trim();
+}
+
+/**
+ * Collapse a thinking markdown block into a single line:
+ * take its last non-empty line, strip block markers, and tail-truncate
+ * to `availableWidth` display columns. Falls back to the original
+ * markdown when there is nothing to show.
+ */
+export function collapseThinking(markdown: string, availableWidth: number): string {
+  const line = stripBlockMarkers(lastNonEmptyLine(markdown));
+  if (!line) return markdown;
+  // Sanitize the width: renderers should always pass a positive number, but a
+  // missing/NaN value must degrade to a sane default instead of leaking NaN.
+  const width = Number.isFinite(availableWidth) && availableWidth >= 8
+    ? Math.floor(availableWidth)
+    : 80;
+  return tailFit(line, width);
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@clapecho233/pi-smart-fold",
+  "version": "0.1.0",
+  "description": "pi coding-agent extension: collapse tool output at startup and fold thinking blocks to a live last line",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "pi",
+    "pi-extension",
+    "pi-package"
+  ],
+  "main": "index.ts",
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "scripts": {
+    "test": "node test/fold.test.mjs"
+  },
+  "engines": {
+    "node": ">=22.18"
+  }
+}

package/test/fold.test.mjs

@@ -0,0 +1,175 @@
+/**
+ * Dependency-free tests for pi-smart-fold's pure helpers.
+ * Run: npm test   (needs Node >= 22.18 for native .ts type stripping)
+ */
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  codePointWidth,
+  displayWidth,
+  tailFit,
+  lastNonEmptyLine,
+  stripBlockMarkers,
+  collapseThinking,
+} from "../lib/fold.ts";
+import { defaultConfig, loadConfig, saveConfig } from "../lib/config.ts";
+
+let passed = 0;
+const check = (name, fn) => {
+  try {
+    fn();
+    passed++;
+  } catch (error) {
+    console.error(`✗ ${name}`);
+    throw error;
+  }
+};
+
+// ---------------------------------------------------------------- width ----
+check("codePointWidth: ascii is 1", () => {
+  assert.equal(codePointWidth("a".codePointAt(0)), 1);
+});
+check("codePointWidth: CJK is 2", () => {
+  assert.equal(codePointWidth("中".codePointAt(0)), 2);
+  assert.equal(codePointWidth("あ".codePointAt(0)), 2);
+  assert.equal(codePointWidth("한".codePointAt(0)), 2);
+});
+check("codePointWidth: emoji is 2", () => {
+  assert.equal(codePointWidth("😀".codePointAt(0)), 2);
+});
+check("codePointWidth: combining mark is 0", () => {
+  assert.equal(codePointWidth(0x0301), 0);
+});
+check("displayWidth: mixed CJK/ascii", () => {
+  assert.equal(displayWidth("abc中de"), 7); // 3 + 2 + 2
+});
+check("displayWidth: ignores ANSI escapes", () => {
+  assert.equal(displayWidth("\u001b[31mabc\u001b[0m"), 3);
+});
+
+// ------------------------------------------------------------- tailFit ----
+check("tailFit: fits → unchanged", () => {
+  assert.equal(tailFit("hello", 10), "hello");
+});
+check("tailFit: exact fit → unchanged", () => {
+  assert.equal(tailFit("hello", 5), "hello");
+});
+check("tailFit: keeps the tail with ellipsis", () => {
+  assert.equal(tailFit("abcdefghij", 5), "…ghij");
+});
+check("tailFit: CJK truncation counts columns", () => {
+  assert.equal(tailFit("一二三四五", 7), "…三四五");
+  assert.equal(displayWidth(tailFit("一二三四五", 7)), 7);
+});
+check("tailFit: never splits a wide char", () => {
+  const out = tailFit("一二三四五", 6);
+  assert.equal(displayWidth(out) <= 6, true);
+  assert.equal(out.startsWith("…"), true);
+});
+check("tailFit: maxWidth < 1 → empty", () => {
+  assert.equal(tailFit("abc", 0), "");
+});
+check("tailFit: non-finite width passes through", () => {
+  assert.equal(tailFit("hello", Number.NaN), "hello");
+});
+
+// ----------------------------------------------------- lastNonEmptyLine ----
+check("lastNonEmptyLine: picks last non-empty", () => {
+  assert.equal(lastNonEmptyLine("first\nsecond\n\n"), "second");
+});
+check("lastNonEmptyLine: skips whitespace lines", () => {
+  assert.equal(lastNonEmptyLine("a\n   \n  b  \n\t\n"), "  b  ");
+});
+check("lastNonEmptyLine: all empty → empty string", () => {
+  assert.equal(lastNonEmptyLine("\n \n"), "");
+});
+
+// ---------------------------------------------------- stripBlockMarkers ----
+check("stripBlockMarkers: heading", () => {
+  assert.equal(stripBlockMarkers("## Heading"), "Heading");
+});
+check("stripBlockMarkers: blockquote", () => {
+  assert.equal(stripBlockMarkers("> quoted text"), "quoted text");
+});
+check("stripBlockMarkers: bullet", () => {
+  assert.equal(stripBlockMarkers("- item"), "item");
+  assert.equal(stripBlockMarkers("* item"), "item");
+});
+check("stripBlockMarkers: ordered list", () => {
+  assert.equal(stripBlockMarkers("12. step"), "step");
+});
+check("stripBlockMarkers: nested markers", () => {
+  assert.equal(stripBlockMarkers("> - nested"), "nested");
+});
+check("stripBlockMarkers: removes code fences", () => {
+  assert.equal(stripBlockMarkers("```ts"), "ts");
+});
+check("stripBlockMarkers: leaves math-ish '>' alone", () => {
+  assert.equal(stripBlockMarkers(">= 5"), ">= 5");
+});
+
+// ---------------------------------------------------- collapseThinking ----
+check("collapseThinking: folds to last line", () => {
+  assert.equal(collapseThinking("first thought\nsecond thought\nthird", 80), "third");
+});
+check("collapseThinking: strips block markers", () => {
+  assert.equal(collapseThinking("plan:\n- [ ] do the thing", 80), "[ ] do the thing");
+});
+check("collapseThinking: empty input passes through", () => {
+  assert.equal(collapseThinking("", 80), "");
+  assert.equal(collapseThinking("\n \n", 80), "\n \n");
+});
+check("collapseThinking: truncates to width, keeping the tail", () => {
+  const out = collapseThinking("start\n" + "x".repeat(200), 21);
+  assert.equal(displayWidth(out) <= 21, true);
+  assert.equal(out.startsWith("…"), true);
+  assert.equal(out.endsWith("xxxxxxxxxxxxxxxxxx"), true);
+});
+check("collapseThinking: CJK line truncated by display columns", () => {
+  const out = collapseThinking("思考开始\n这是一段很长很长的思考内容", 11);
+  assert.equal(displayWidth(out) <= 11, true);
+  assert.equal(out.startsWith("…"), true);
+});
+check("collapseThinking: clamps tiny widths", () => {
+  assert.equal(typeof collapseThinking("a\nb", 0), "string");
+});
+check("collapseThinking: non-finite width degrades to default 80", () => {
+  assert.equal(collapseThinking("a\nb", Number.NaN), "b");
+  assert.equal(collapseThinking("a\nb", undefined), "b");
+});
+
+// -------------------------------------------------------------- config ----
+check("config: defaults when file missing", () => {
+  const dir = mkdtempSync(join(tmpdir(), "smart-fold-"));
+  try {
+    assert.deepEqual(loadConfig(dir), defaultConfig);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+check("config: save/load roundtrip and partial merge", () => {
+  const dir = mkdtempSync(join(tmpdir(), "smart-fold-"));
+  try {
+    assert.equal(saveConfig(dir, { toolsFold: false, thinkingFold: true }), true);
+    assert.deepEqual(loadConfig(dir), { toolsFold: false, thinkingFold: true });
+    // partial file merges over defaults
+    writeFileSync(join(dir, "smart-fold.config.json"), '{"thinkingFold": false}', "utf8");
+    assert.deepEqual(loadConfig(dir), { toolsFold: true, thinkingFold: false });
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+check("config: broken JSON falls back to defaults", () => {
+  const dir = mkdtempSync(join(tmpdir(), "smart-fold-"));
+  try {
+    writeFileSync(join(dir, "smart-fold.config.json"), "{oops", "utf8");
+    assert.deepEqual(loadConfig(dir), defaultConfig);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+console.log(`✓ ${passed} test groups passed`);