@bachi/pi-coder 1.0.0

package/extensions/below-editor-after-statusline.ts

@@ -0,0 +1,118 @@
+/**
+ * below-editor-after-statusline — 把「编辑器下方」的扩展 widget 挪到 statusline **下面**。
+ *
+ * 要解决的问题：pi-subagents 的 fleet 状态行（`1 active agent · ↓ 2.7k window · ↓/← to inspect`，
+ * widget key `subagent-fleet-status`，见它的 `src/tui/fleet-status.ts`）注册为
+ * `placement: "belowEditor"`，而 pi 的挂载顺序是
+ *
+ *     [document, pendingMessages, status, widgetContainerAbove,
+ *      editor, widgetContainerBelow, footer]
+ *
+ * （`interactive-mode.js` 的 `mountInteractiveTui`）—— 于是这行提示出现在**输入框与 statusline
+ * 之间**，把 statusline 挤到屏幕最底部。这一行是**状态信息**而不是输入区的一部分，视觉上应当
+ * 沉到 statusline 下面去，让「输入框 → statusline」保持紧邻。
+ *
+ * 为什么只能改结构：pi-subagents 的 `fleetViewPlacement` 只接受 `aboveEditor` / `belowEditor`
+ * （`shared/types.ts` 的 `FleetViewPlacement`，默认 belowEditor），pi 的 `setWidget` 也只有这两个
+ * 位置，没有任何「footer 之下」的 placement；footer 本身（statusline 那些行）由
+ * 本地 `extensions/statusline/` 通过 `ctx.ui.setFooter()` 独占，扩展拿不到它的渲染结果去拼接。
+ *
+ * 做法：pi-tui 的 `TUI` / `Container` 把 `children` 作为公开字段暴露，而 `TuiBase.render()`
+ * 就是**按数组顺序**拼接每个 child 的行（`tui.js`），所以只要把
+ * 「编辑器下方的 widget 容器」这个 child 挪到数组末尾（footer 容器之后）即可。
+ *
+ * 怎么认出是哪个 child：不猜下标 —— 先注册一个**探针 widget**（`placement: belowEditor`，
+ * render 返回空数组所以不可见），从 widget 工厂拿到 TUI，再遍历 `children` 找到「子树里装着
+ * 那个探针组件」的顶层 child，那就是编辑器下方的 widget 容器；把它移到末尾，然后删掉探针。
+ * 探针的注册与删除都发生在同一 tick 内（`setWidget` 只是 `requestRender()`，不会立刻出帧），
+ * 所以屏幕上不会闪出任何东西。下面那只 widget 容器里的现有内容（fleet 行）原样跟着搬家。
+ *
+ * 顺序会保持住：pi 只在 init 与切换 TUI 模式时调 `mountInteractiveTui`，而 `switchTuiMode`
+ * 是 `[...previousUi.children]` 原样再挂一遍（顺序被复制），所以移动一次就够了；`/reload`
+ * 后 `session_start` 会再跑一次，同样幂等（已经在末尾 → 直接返回）。
+ *
+ * 刻意不做的事：
+ *   - 不改 pi-subagents 的任何文件（npm 包，升级即丢），也不改 pi 本身；
+ *   - fullscreen（`--tui-mode fullscreen`）下 pi 用的是自己那棵 viewport 布局树
+ *     （`createChatViewport` + `setLayoutRoot`），容器顺序由那棵树决定，本扩展**不保证**在
+ *     fullscreen 下生效 —— 本机 `settings.json` 的 `tuiMode` 是 `regular`（实测布局就是这个
+ *     顺序），fullscreen 下最坏情况只是回到「提示行在 statusline 上面」；
+ *   - 找不到那个 child（pi 改了挂载结构）时**什么都不做**，不抛错、不猜下标 —— 界面回到改动前
+ *     的样子，而不是错位；`tui.children` 万一变成只读数组（`splice`/`push` 抛 TypeError）
+ *     同理：只当「没搬成」，绝不让异常漏给宿主去弹 extension error。
+ *
+ * 环境变量：
+ *   PI_BELOW_EDITOR_AFTER_STATUSLINE=off   启动时关闭本扩展
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+/** 探针 widget 的 key（只在本次调用里短暂存在）。 */
+const PROBE_KEY = "below-editor-order-probe";
+
+const DISABLED = (process.env.PI_BELOW_EDITOR_AFTER_STATUSLINE ?? "").trim().toLowerCase() === "off";
+
+/** 子树里是否装着这个组件 —— 按对象身份比对，不按形状（同形状的组件到处都是）。 */
+function containsComponent(node: unknown, target: unknown, seen = new Set<unknown>()): boolean {
+	if (node === target) return true;
+	if (node === null || typeof node !== "object" || seen.has(node)) return false;
+	seen.add(node);
+	const children = (node as { children?: unknown }).children;
+	if (!Array.isArray(children)) return false;
+	return children.some((child) => containsComponent(child, target, seen));
+}
+
+export default function (pi: ExtensionAPI): void {
+	if (DISABLED) return;
+
+	function moveBelowEditorWidgetsLast(ctx: ExtensionContext): void {
+		if (ctx.mode !== "tui" || !ctx.hasUI) return;
+
+		let tui: unknown;
+		let probe: unknown;
+		try {
+			// 探针必须显式声明 belowEditor —— 默认位置上方的那个容器不是要搬的对象，
+			// 弄错会把「编辑器上方」的 widget 区（任务清单 / 摘要）整块搬到 footer 底下。
+			ctx.ui.setWidget(
+				PROBE_KEY,
+				(widgetTui, _theme) => {
+					tui = widgetTui;
+					const component = { render: (): string[] => [], invalidate() {} };
+					probe = component;
+					return component;
+				},
+				{ placement: "belowEditor" },
+			);
+		} catch {
+			// 没有 UI / ctx 已失效：什么都别做。
+			return;
+		}
+
+		try {
+			const children = (tui as { children?: unknown } | undefined)?.children;
+			if (!Array.isArray(children)) return;
+			const index = children.findIndex((child) => containsComponent(child, probe));
+			// 找不到（pi 换了内部结构）或本来就在最后（footer 之后）→ 不动。
+			if (index < 0 || index >= children.length - 1) return;
+			// 数组万一变成只读（splice 抛 TypeError）也只当作「没搬成」：
+			// 界面回到改动前的顺序，绝不把异常漏给宿主弹 extension error。
+			try {
+				const [container] = children.splice(index, 1);
+				children.push(container);
+			} catch {
+				// 只读 / 诡异代理：保持原顺序。
+			}
+		} finally {
+			try {
+				ctx.ui.setWidget(PROBE_KEY, undefined);
+			} catch {
+				// stale ctx：探针随会话一起消失，不影响已完成的重排。
+			}
+		}
+	}
+
+	// init 时 TUI 先挂载、随后才 emit session_start（`InteractiveMode.init` →
+	// `bindCurrentSessionExtensions`），所以这里一定能拿到已经挂好的组件树。
+	// resume / fork / /reload 都会触发，重复执行是幂等的。
+	pi.on("session_start", async (_event, ctx) => moveBelowEditorWidgetsLast(ctx));
+}

package/extensions/clear-command.ts

@@ -0,0 +1,29 @@
+/**
+ * 给 pi 增加 /clear 指令，效果等同于内置的 /new（开一个全新会话，清空当前上下文）。
+ *
+ * 实现方式：注册扩展命令 clear，内部调用 ctx.newSession() —— 这正是内置 /new 走的
+ * 同一条会话替换流程（旧会话先触发 session_shutdown，再绑定新会话，新会话拿到
+ * session_start），所以行为、快捷键语义、落盘格式都和 /new 完全一致。
+ *
+ * 细节：
+ *   - 先 await ctx.waitForIdle()：agent 正在跑的时候直接 newSession 会和运行中的
+ *     turn 抢会话，等这轮（含自动重试 / 自动压缩 / 排队续跑）结束再换才安全。
+ *   - 不传 parentSession / setup / withSession，即纯净的新会话，不做任何上下文搬运。
+ *   - result.cancelled 说明有别的扩展在 session_before_new 里否决了这次切换，
+ *     此时给一条提示而不是静默失败。
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+	pi.registerCommand("clear", {
+		description: "Start a new session (alias of /new)",
+		handler: async (_args, ctx) => {
+			await ctx.waitForIdle();
+			const result = await ctx.newSession();
+			if (result?.cancelled) {
+				ctx.ui.notify("New session cancelled by an extension", "warning");
+			}
+		},
+	});
+}

package/extensions/cwd-statusline.ts

@@ -0,0 +1,39 @@
+/**
+ * cwd-statusline — 在 statusline 底部单独一行显示当前工作目录（完整绝对路径）
+ *
+ * 走 ctx.ui.setStatus() 输出一条 extension status，由本地 statusline 扩展
+ * （`extensions/statusline/`）渲染在主行下面的第二行：那条路径不被任何路径压缩规则处理，
+ * 所以看得到完整 pwd。超长只按终端宽度截断加省略号，不折行。
+ *
+ * 历史备注：这一行原来由第三方包 `npm:@narumitw/pi-statusline` 渲染。它会先 trim() status 文本、
+ * 再按 emoji 拆出图标，配置里的 `extensionStatusIcons.cwd = " 📁"` 是唯一能控制行首缩进的地方；
+ * 现在的 statusline 扩展直接渲染 status 原文（trim 后统一缩进一格），所以 PI_CWD_ICON 说了算。
+ *
+ * 可调环境变量：
+ *   PI_CWD_STATUSLINE  设为 off 关闭本扩展
+ *   PI_CWD_ICON        图标，默认 📁
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+const STATUS_KEY = "cwd";
+const ICON = process.env.PI_CWD_ICON ?? " 📁";
+const DISABLED = (process.env.PI_CWD_STATUSLINE ?? "").toLowerCase() === "off";
+
+export default function (pi: ExtensionAPI) {
+	if (DISABLED) return;
+
+	const refresh = (ctx: ExtensionContext) => {
+		if (!ctx.hasUI) return;
+		// statusline 扩展会把 status 文本原样渲染（只 trim 一次并统一缩进一格），
+		// 所以这里只发「图标 + 空格 + 绝对路径」。
+		ctx.ui.setStatus(STATUS_KEY, `${ICON} ${ctx.cwd}`);
+	};
+
+	// session_start：启动 / 新建 / resume / fork 都会触发，是设置初始值的地方
+	pi.on("session_start", async (_event, ctx) => refresh(ctx));
+	// session_info_changed：会话元信息变化时兜底刷新
+	pi.on("session_info_changed", async (_event, ctx) => refresh(ctx));
+	// turn_start：每轮开始时刷新一次，保证目录信息始终是最新的
+	pi.on("turn_start", async (_event, ctx) => refresh(ctx));
+}

package/extensions/exit-command.ts

@@ -0,0 +1,59 @@
+/**
+ * 让 pi 支持像 Claude Code 那样直接输入 exit / quit 退出。
+ *
+ * 实现方式：监听 `input` 事件（在扩展命令之后、skill/template 展开之前触发），
+ * 当输入去空格后正好是退出词时返回 { action: "handled" }（跳过 agent，不进 LLM），
+ * 同时调用 ctx.shutdown() 做优雅退出 —— 会话照常落盘，退出前会触发 session_shutdown。
+ *
+ * 细节：
+ *   - 只在 ctx.mode === "tui" 时生效：--print / --mode json / --mode rpc 里 "exit" 仍是普通 prompt
+ *     （注意 --print 的 event.source 也是 "interactive"，所以不能只靠 source 判断；
+ *     且 print 模式下 shutdown 本来就是 no-op，拦下来只会静默丢掉 prompt）。
+ *   - 精确整行匹配，所以 "exit the loop and print a summary" 这类正常提问不受影响；
+ *     带附件（图片）时也放行。
+ *   - 大小写不敏感；默认退出词 exit / quit / bye。
+ *     可用环境变量覆盖：PI_EXIT_WORDS="exit,quit"；设为 "off" 则整体关闭。
+ *   - 顺带注册 /exit 作为内置 /quit 的别名。
+ *   - agent 正在跑的时候输入 exit：shutdown 会被推迟到空闲后再执行，即等当前这轮结束才退出。
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const DEFAULT_WORDS = ["exit", "quit", "bye"];
+
+function exitWords(): string[] | null {
+	const raw = process.env.PI_EXIT_WORDS;
+	if (!raw) return DEFAULT_WORDS;
+	const trimmed = raw.trim();
+	if (!trimmed) return DEFAULT_WORDS;
+	if (trimmed.toLowerCase() === "off") return null;
+	const words = trimmed
+		.split(",")
+		.map((w) => w.trim().toLowerCase())
+		.filter(Boolean);
+	return words.length > 0 ? words : null;
+}
+
+export default function (pi: ExtensionAPI) {
+	const words = exitWords();
+	if (!words) return; // PI_EXIT_WORDS=off
+
+	pi.on("input", async (event, ctx) => {
+		if (ctx.mode !== "tui" || event.source !== "interactive") return { action: "continue" };
+		if (event.images && event.images.length > 0) return { action: "continue" };
+
+		const text = event.text.trim().toLowerCase();
+		if (!words.includes(text)) return { action: "continue" };
+
+		ctx.ui.notify("bye 👋", "info");
+		ctx.shutdown();
+		return { action: "handled" };
+	});
+
+	pi.registerCommand("exit", {
+		description: "Exit pi cleanly (alias of /quit)",
+		handler: async (_args, ctx) => {
+			ctx.shutdown();
+		},
+	});
+}

package/extensions/fenceless-code-block/index.test.ts

@@ -0,0 +1,208 @@
+/**
+ * Tests for index.ts — 端到端：pi 自己的扩展加载器真的加载本扩展，补丁真的落在 **pi 渲染用的
+ * 那个** `Markdown` 类上，再用 pi 自己的 `AssistantMessageComponent` 渲染一条 assistant 消息，
+ * 断言围栏消失、语法着色还在、**没有任何底色**。
+ *
+ * Run with:  node --test clients/pi/extensions/fenceless-code-block/index.test.ts
+ *
+ * 为什么非得绕这一圈（不直接 new 一个 Markdown 来渲染）：这个特性的**唯一**风险就是「补丁打在
+ * 另一个类上」—— `pi` 命令跑的是 `dist/bundle/cli.js`，pi-tui 内联在 chunk 里，而扩展 import 到
+ * 的是扩展加载器 aliases / virtualModules 给的那一份。只有真过一遍 pi 的加载器 + pi 自己的渲染
+ * 组件，才能证明这两者**是同一个类**（链路见 `render.ts` 文件头）。
+ * `render.test.ts` 覆盖纯逻辑与边界条件，这里只证明「装得上，而且作用在 pi 身上」。
+ * 找不到本机 pi 的库入口就整体 skip（不假装通过）。
+ */
+
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "index.ts");
+const SKIP = "找不到本机 pi 的库入口（装过 pi 才有）";
+const ESC = "\u001b";
+
+/**
+ * pi 的库入口（非 CLI）：bundle 是 `pi` 实际跑的形态，dist 是 node 构建形态。
+ *
+ * 先从 `pi` 可执行文件反查**真正的安装位置**（pnpm/npm 的 shim 脚本里留有
+ * `# cmd-shim-target=<绝对路径>`；npm 在 Unix 上则是符号链接，两种都试），再退回
+ * `~/.pi/agent/npm` 那份副本 —— 后者是**扩展包的安装根**，`pi update --extensions` 会用
+ * `--config.auto-install-peers=false` 把自动装进去的 `@earendil-works/pi-*` 同伴包剪掉，
+ * 于是那份副本只剩空壳（文件都在、import 报 `ERR_MODULE_NOT_FOUND`；2026-09 升
+ * pi-subagents 0.68.0 时实测踩到）。
+ *
+ * 判定方式是**能不能真 import**，不是路径存不存在 —— 只有真 import 一次才分得清空壳。
+ * 全都不行就返回 undefined，调用方整体 skip（不假装通过）。
+ */
+async function findPiLibraryEntry(): Promise<string | undefined> {
+	const candidates: string[] = [];
+	if (process.env.PI_TEST_PI_ENTRY) candidates.push(process.env.PI_TEST_PI_ENTRY);
+
+	for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
+		if (!dir) continue;
+		const shimPath = path.join(dir, "pi");
+		try {
+			// npm 的 shim 是符号链接
+			const real = fs.realpathSync(shimPath);
+			if (real !== shimPath) candidates.push(path.join(path.dirname(real), "index.js"));
+		} catch {
+			// 不是符号链接 / 不存在：看下面的 shim 脚本
+		}
+		try {
+			const match = /^# cmd-shim-target=(.+)$/m.exec(fs.readFileSync(shimPath, "utf8"));
+			if (match?.[1]) candidates.push(path.join(path.dirname(match[1].trim()), "index.js"));
+		} catch {
+			// 读不到这个 shim：跳过
+		}
+	}
+
+	const packageDir = path.join(os.homedir(), ".pi/agent/npm/node_modules/@earendil-works/pi-coding-agent");
+	candidates.push(path.join(packageDir, "dist/bundle/index.js"), path.join(packageDir, "dist/index.js"));
+
+	for (const candidate of candidates) {
+		if (!fs.existsSync(candidate)) continue;
+		try {
+			await import(pathToFileURL(candidate).href);
+			return candidate;
+		} catch {
+			// 空壳副本：换下一个候选
+		}
+	}
+	return undefined;
+}
+
+const piEntry = await findPiLibraryEntry();
+const skip = piEntry === undefined ? SKIP : false;
+
+type Handler = (event: unknown, ctx: unknown) => Promise<unknown> | unknown;
+
+interface LoadedExtension {
+	handlers: Map<string, Handler[]>;
+	commands: Map<string, unknown>;
+	errors: Array<{ path: string; error: string }>;
+}
+
+interface PiApi {
+	discoverAndLoadExtensions: (
+		configuredPaths: string[],
+		cwd: string,
+		agentDir?: string,
+		eventBus?: unknown,
+	) => Promise<{ extensions: LoadedExtension[]; errors: Array<{ path: string; error: string }> }>;
+	getMarkdownTheme: () => Record<string, unknown>;
+	initTheme: (name?: string) => void;
+	AssistantMessageComponent: new (
+		message: unknown,
+		hideThinkingBlock: boolean,
+		markdownTheme: unknown,
+		hiddenThinkingLabel: string,
+		outputPad: number,
+		transformers: unknown[],
+	) => { render(width: number): string[] };
+}
+
+let pi: PiApi | undefined;
+if (piEntry) pi = (await import(pathToFileURL(piEntry).href)) as unknown as PiApi;
+
+function createTestBus(): { emit(channel: string, data: unknown): void; on(channel: string, handler: (data: unknown) => void): () => void } {
+	const handlers = new Map<string, Set<(data: unknown) => void>>();
+	return {
+		on(channel, handler) {
+			const set = handlers.get(channel) ?? new Set<(data: unknown) => void>();
+			handlers.set(channel, set);
+			set.add(handler);
+			return () => {
+				set.delete(handler);
+			};
+		},
+		emit(channel, data) {
+			for (const handler of [...(handlers.get(channel) ?? [])]) handler(data);
+		},
+	};
+}
+
+function makeWorkspace(): { agentDir: string; projectDir: string; cleanup: () => void } {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fenceless-code-block-"));
+	const agentDir = path.join(root, "agent");
+	const projectDir = path.join(root, "project");
+	fs.mkdirSync(agentDir);
+	fs.mkdirSync(projectDir);
+	return {
+		agentDir,
+		projectDir,
+		cleanup: () => fs.rmSync(root, { recursive: true, force: true }),
+	};
+}
+
+/** 用 pi 自己的加载器加载本扩展（`./render.ts` 的 import 也一起验证）。 */
+async function loadExtension(workspace: { agentDir: string; projectDir: string }): Promise<LoadedExtension> {
+	assert.ok(pi);
+	const loaded = await pi.discoverAndLoadExtensions(
+		[EXTENSION_PATH],
+		workspace.projectDir,
+		workspace.agentDir,
+		createTestBus(),
+	);
+	assert.deepEqual(loaded.errors, [], "pi 的扩展加载器不应该报错");
+	assert.equal(loaded.extensions.length, 1);
+	const extension = loaded.extensions[0];
+	assert.ok(extension);
+	return extension;
+}
+
+/** 走 pi 自己的组件渲染一条 assistant 文本消息（`outputPad = 1`，与真实渲染一致）。 */
+function renderAssistantText(text: string, width = 80): string[] {
+	assert.ok(pi);
+	pi.initTheme("dark");
+	// 真实路径上 pi 用的是 getMarkdownThemeWithSettings()（= 这里再合并设置里的缩进）。
+	const markdownTheme = { ...pi.getMarkdownTheme(), codeBlockIndent: "  " };
+	const message = { role: "assistant", content: [{ type: "text", text }], stopReason: "stop" };
+	const component = new pi.AssistantMessageComponent(message, false, markdownTheme, "Thinking...", 1, []);
+	return component.render(width);
+}
+
+/** 去掉 CSI 颜色与 OSC 133 标记（assistant 消息首尾各挂一个）。 */
+const plainText = (line: string): string =>
+	line.replace(/\u001b\][^\u0007]*\u0007/g, "").replace(/\u001b\[[0-9;]*m/g, "");
+
+test("扩展能被 pi 的加载器加载（本扩展不注册事件与命令）", { skip, timeout: 30_000 }, async () => {
+	const workspace = makeWorkspace();
+	try {
+		const extension = await loadExtension(workspace);
+		assert.equal(extension.handlers.size, 0, "补丁在模块求值时装好，不需要 session_start");
+		assert.equal(extension.commands.size, 0, "本扩展不提供命令");
+	} finally {
+		workspace.cleanup();
+	}
+});
+
+test("pi 渲染的代码块没有围栏，且不铺任何底色", { skip, timeout: 30_000 }, async () => {
+	const workspace = makeWorkspace();
+	try {
+		await loadExtension(workspace);
+
+		const lines = renderAssistantText("before\n\n```js\nconst x = 1;\n```\n\nafter");
+		const plain = lines.map(plainText);
+
+		assert.equal(plain.some((line) => line.includes("```")), false, "围栏不该出现");
+		assert.equal(plain.some((line) => line.trim() === "js"), false, "语言标签不该单独占一行");
+
+		const codeLine = lines.find((line) => plainText(line).includes("const x = 1;"));
+		assert.ok(codeLine, "代码行应该在");
+		assert.ok(codeLine.includes(`${ESC}[38;`), "语法着色不该被我们的渲染吃掉");
+		assert.equal(codeLine.includes(`${ESC}[48;`), false, "代码行不该有底色");
+		assert.equal(lines.some((line) => line.includes(`${ESC}[48;`)), false, "整条消息都不该出现底色 SGR");
+
+		assert.equal(plainText(codeLine).trim(), "const x = 1;", "只留 pi 的缩进，行尾没有多余内容");
+		assert.ok(plain.some((line) => line.includes("before")), "代码块前面的正文还在");
+		assert.ok(plain.some((line) => line.includes("after")), "代码块后面的正文还在");
+		for (const line of plain.filter((text) => text.trim() !== "")) {
+			assert.equal(line.length, 80, "pi 的整行补白仍然生效");
+		}
+	} finally {
+		workspace.cleanup();
+	}
+});

package/extensions/fenceless-code-block/index.ts

@@ -0,0 +1,28 @@
+/**
+ * fenceless-code-block — Markdown 代码块去掉围栏（不加底色）
+ *
+ * 本文件只做接线：把 pi-tui 的量度 / 折行函数交给 `render.ts` 的纯逻辑。原型补丁本身在
+ * `installFencelessCodeBlocks` 里 —— 为什么必须打原型、为什么打得中（bundle 内联 vs 加载器
+ * virtualModules），见 `render.ts` 的文件头。
+ *
+ * 只管围栏：代码正文保持 pi 原本的 `mdCodeBlock` 前景色，不铺底色、不碰引用块的 gutter，
+ * 也不改行尾补白（那是 `Markdown.render()` 自己的事）。所以不需要 `ctx`、不注册任何事件 ——
+ * 扩展在模块求值时就把补丁装好。
+ *
+ * `PI_FENCELESS_CODE=off` 关闭（与 `PI_LOGO=off` 同一套约定）。
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Markdown, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+
+import { installFencelessCodeBlocks } from "./render.ts";
+
+export default function (pi: ExtensionAPI) {
+	if (process.env.PI_FENCELESS_CODE === "off") return;
+
+	installFencelessCodeBlocks({
+		Markdown,
+		measure: visibleWidth,
+		wrap: wrapTextWithAnsi,
+	});
+}

package/extensions/fenceless-code-block/render.test.ts

@@ -0,0 +1,177 @@
+/**
+ * Tests for render.ts — 代码块去围栏的纯逻辑（行渲染 + 原型补丁）。
+ *
+ * Run with:  node --test clients/pi/extensions/fenceless-code-block/render.test.ts
+ *
+ * 被测模块不 import pi / pi-tui（量度、折行、Markdown 类都是注入的），所以这里喂假实现：
+ * ASCII = 1 列、CJK 全角 = 2 列（口径与 pi-tui 的 visibleWidth 一致）；折行是朴素的按列硬切
+ * （输入不含 ANSI，正好等价于 wrapTextWithAnsi 在"没有可断词"情形下的结果）；"Markdown 类"
+ * 只是个带 theme 字段和 renderToken 的假类，用来验证补丁的接线（转发、幂等、读实例上的主题）。
+ * 真实的端到端链路（pi 自己的加载器 → pi 自己的渲染组件）在 `index.test.ts`。
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { installFencelessCodeBlocks, renderCodeBlockLines } from "./render.ts";
+
+const ESC = "\u001b";
+const stripAnsi = (text: string): string => text.replace(/\u001b\[[0-9;]*m/g, "");
+/** CJK 全角区间（够这几条用例用；口径与 pi-tui 的 visibleWidth 一致）。 */
+const WIDE = /[\u1100-\u115f\u2e80-\ua4cf\uac00-\ud7a3\uf900-\ufaff\ufe30-\ufe6f\uff00-\uff60\uffe0-\uffe6]/;
+const charWidth = (ch: string): number => (WIDE.test(ch) ? 2 : 1);
+const measure = (text: string): number => [...stripAnsi(text)].reduce((sum, ch) => sum + charWidth(ch), 0);
+/** 朴素折行：按列硬切。输入不含 ANSI，够用。 */
+const wrap = (text: string, width: number): string[] => {
+	if (measure(text) <= width) return [text];
+	const pieces: string[] = [];
+	let current = "";
+	let used = 0;
+	for (const ch of text) {
+		const w = charWidth(ch);
+		if (used > 0 && used + w > width) {
+			pieces.push(current);
+			current = "";
+			used = 0;
+		}
+		current += ch;
+		used += w;
+	}
+	pieces.push(current);
+	return pieces;
+};
+
+describe("renderCodeBlockLines", () => {
+	it("围栏不参与：正文按缩进铺开", () => {
+		assert.deepEqual(renderCodeBlockLines("a\nbb", 10, { measure, wrap }), ["  a", "  bb"]);
+	});
+
+	it("行尾不补白：补白交给 pi 的 Markdown.render()，这里只保证不超过 width", () => {
+		const lines = renderCodeBlockLines("a", 10, { measure, wrap });
+		assert.deepEqual(lines, ["  a"], "末尾不该有我们加的空格");
+		for (const line of lines) assert.ok(measure(line) <= 10);
+	});
+
+	it("不注入任何自己的转义（没有底色、没有额外的 SGR）", () => {
+		for (const line of renderCodeBlockLines("a\nbb", 10, { measure, wrap })) {
+			assert.equal(line.includes(ESC), false, "没有高亮时返回的应该是纯文本");
+		}
+	});
+
+	it("长行自己先折，每行都不超过 width（外层不会再有第二次折行）", () => {
+		const lines = renderCodeBlockLines("xxxxxxxxxx", 6, { measure, wrap });
+		assert.deepEqual(lines, ["  xxxx", "  xxxx", "  xx"]);
+		for (const line of lines) assert.ok(measure(line) <= 6);
+	});
+
+	it("缩进放不下时丢缩进，行宽仍然不超过 width", () => {
+		const lines = renderCodeBlockLines("abcdef", 3, { measure, wrap, indent: "    " });
+		assert.deepEqual(lines, ["abc", "def"]);
+		for (const line of lines) assert.ok(measure(line) <= 3);
+	});
+
+	it("空代码块 / 高亮返回空数组都至少留一行", () => {
+		assert.deepEqual(renderCodeBlockLines("", 4, { measure, wrap }), ["  "], "空代码块留一行，只带缩进");
+		assert.deepEqual(
+			renderCodeBlockLines("a", 4, { measure, wrap, highlight: () => [] }),
+			["  a"],
+			"高亮没产出时退回纯文本，不能一行都不画",
+		);
+	});
+
+	it("语言标签与正文一起交给高亮函数", () => {
+		const seen: Array<[string, string | undefined]> = [];
+		const lines = renderCodeBlockLines("const x = 1;", 40, {
+			measure,
+			wrap,
+			lang: "js",
+			highlight: (code, lang) => {
+				seen.push([code, lang]);
+				return [`<hl>${code}</hl>`];
+			},
+		});
+		assert.deepEqual(seen, [["const x = 1;", "js"]]);
+		assert.deepEqual(lines, ["  <hl>const x = 1;</hl>"], "着色行原样保留，不再包一层");
+	});
+
+	it("没有高亮函数时用兜底着色（等价官方渲染器的 else 分支）", () => {
+		assert.deepEqual(renderCodeBlockLines("a", 8, { measure, wrap, fallbackStyle: (text) => `[${text}]` }), ["  [a]"]);
+	});
+
+	it("CJK 按两列计：折行按列，不按字符", () => {
+		assert.deepEqual(renderCodeBlockLines("中文中文", 10, { measure, wrap }), ["  中文中文"]);
+		// 可用宽度 6 列时装不下 8 列正文：切成 6 + 2。
+		assert.deepEqual(renderCodeBlockLines("中文中文", 8, { measure, wrap }), ["  中文中", "  文"]);
+	});
+});
+
+interface FakeCalls {
+	forwarded: unknown[][];
+}
+
+/** 假 Markdown 类：renderToken 记下参数并返回可辨认的文本。 */
+function makeFakeMarkdown(theme: Record<string, unknown> = {}) {
+	const calls: FakeCalls = { forwarded: [] };
+	class FakeMarkdown {
+		theme: Record<string, unknown>;
+		constructor() {
+			this.theme = theme;
+		}
+		renderToken(token: { type?: string }, width: number, nextType?: string, styleContext?: unknown): string[] {
+			calls.forwarded.push([token, width, nextType, styleContext]);
+			return [`<<original ${token?.type}>>`];
+		}
+	}
+	return { FakeMarkdown, calls };
+}
+
+describe("installFencelessCodeBlocks", () => {
+	it("只接管 code token：其它 token 连参数一起原样转给内置渲染器", () => {
+		const { FakeMarkdown, calls } = makeFakeMarkdown();
+		assert.equal(installFencelessCodeBlocks({ Markdown: FakeMarkdown, measure, wrap }), true);
+
+		const md = new FakeMarkdown();
+		const context = { marker: 1 };
+		assert.deepEqual(md.renderToken({ type: "paragraph" }, 12, "space", context), ["<<original paragraph>>"]);
+		assert.deepEqual(calls.forwarded, [[{ type: "paragraph" }, 12, "space", context]]);
+	});
+
+	it("code token 渲染成无围栏的行，并把 lang 交给实例主题上的高亮", () => {
+		const { FakeMarkdown } = makeFakeMarkdown({
+			codeBlockIndent: "  ",
+			highlightCode: (code: string, lang?: string) => [`<${lang}>${code}`],
+		});
+		installFencelessCodeBlocks({ Markdown: FakeMarkdown, measure, wrap });
+
+		assert.deepEqual(new FakeMarkdown().renderToken({ type: "code", text: "const x = 1;", lang: "js" }, 20), [
+			"  <js>const x = 1;",
+		]);
+	});
+
+	it("采信实例 theme 上的 codeBlockIndent", () => {
+		const { FakeMarkdown } = makeFakeMarkdown({ codeBlockIndent: "    " });
+		installFencelessCodeBlocks({ Markdown: FakeMarkdown, measure, wrap });
+		assert.deepEqual(new FakeMarkdown().renderToken({ type: "code", text: "a" }, 6), ["    a"]);
+	});
+
+	it("装了两次只包一层（/reload 幂等）", () => {
+		const { FakeMarkdown } = makeFakeMarkdown({ codeBlockIndent: "  " });
+		assert.equal(installFencelessCodeBlocks({ Markdown: FakeMarkdown, measure, wrap }), true);
+		assert.equal(installFencelessCodeBlocks({ Markdown: FakeMarkdown, measure, wrap }), false);
+		assert.deepEqual(new FakeMarkdown().renderToken({ type: "code", text: "a" }, 4), ["  a"]);
+	});
+
+	it("nextType 不是 space 时补一个空行", () => {
+		const { FakeMarkdown } = makeFakeMarkdown({ codeBlockIndent: "  " });
+		installFencelessCodeBlocks({ Markdown: FakeMarkdown, measure, wrap });
+
+		assert.deepEqual(new FakeMarkdown().renderToken({ type: "code", text: "a" }, 3, "space"), ["  a"]);
+		assert.deepEqual(new FakeMarkdown().renderToken({ type: "code", text: "a" }, 3, "paragraph"), ["  a", ""]);
+	});
+
+	it("原型没有 renderToken 时什么都不做、不抛", () => {
+		const Markdown = { prototype: {} as Record<string | symbol, unknown> };
+		assert.equal(installFencelessCodeBlocks({ Markdown, measure, wrap }), false);
+		assert.equal(Object.keys(Markdown.prototype).length, 0);
+	});
+});