pi-tui-footer 1.2.5 → 1.2.7

package/README.md

@@ -43,6 +43,21 @@ pi update --extensions
 
 也可在 pi 内通过 `/pi-tui` 命令调整。
 
+### 圆角工具框与第三方工具
+
+`roundedTools` 开启时，除 8 个内置工具（read、write、edit、bash、powershell、grep、find、ls）外，也会自动拦截并为第三方扩展注册的工具（如 pi-fff 的 `ffgrep`、`fffind`、`fff-multi-grep`，或其 override 模式接管的 `grep`/`find`）添加圆角边框。
+
+**加载顺序**：需要在 `~/.pi/agent/settings.json` 的 `packages` 中将 `pi-tui-footer` 排在第三方扩展（如 `@ff-labs/pi-fff`）**之前**，以确保 proxy 在工具注册前生效：
+
+```json
+{
+  "packages": [
+    "npm:pi-tui-footer",
+    "npm:@ff-labs/pi-fff"
+  ]
+}
+```
+
 ## 致谢
 
 本项目是以下两个开源项目的深度融合集成：

package/extensions/config.ts

@@ -1,10 +1,6 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import {
-	DEFAULT_FULLSCREEN_WHEEL_SCROLL_LINES,
-	normalizeFullscreenWheelScrollLines,
-} from "./fullscreen-scroll.ts";
 import type { IconMode } from "./icons.ts";
 
 export type SettingsLanguage = "en" | "zh";
@@ -42,17 +38,12 @@ export interface ThinkingPeekConfig {
 	lines: ThinkingPeekLines;
 }
 
-export interface FullscreenConfig {
-	wheelScrollLines: number;
-}
-
 export interface OpenTuiConfig {
 	enabled: boolean;
 	roundedTools: boolean;
 	inlineFooter: boolean;
 	settingsLanguage: SettingsLanguage;
 	cursorStyle: CursorStyle;
-	fullscreen: FullscreenConfig;
 	icons: {
 		mode: IconMode;
 	};
@@ -67,9 +58,6 @@ export const DEFAULT_CONFIG: OpenTuiConfig = {
 	inlineFooter: false,
 	settingsLanguage: "en",
 	cursorStyle: "block",
-	fullscreen: {
-		wheelScrollLines: DEFAULT_FULLSCREEN_WHEEL_SCROLL_LINES,
-	},
 	icons: {
 		mode: "auto",
 	},
@@ -155,27 +143,23 @@ export function loadConfig(notify?: (msg: string, level: "warning" | "info") =>
 		const raw = readFileSync(path, "utf8");
 		const parsed: unknown = JSON.parse(raw);
 		const config = deepMerge(DEFAULT_CONFIG, parsed);
+		if (typeof config.inlineFooter !== "boolean") {
+			config.inlineFooter = DEFAULT_CONFIG.inlineFooter;
+		}
+		if (typeof config.roundedTools !== "boolean") {
+			config.roundedTools = DEFAULT_CONFIG.roundedTools;
+		}
 		if (config.settingsLanguage !== "en" && config.settingsLanguage !== "zh") {
 			config.settingsLanguage = DEFAULT_CONFIG.settingsLanguage;
 		}
 		if (config.cursorStyle !== "block" && config.cursorStyle !== "bar" && config.cursorStyle !== "underline") {
 			config.cursorStyle = DEFAULT_CONFIG.cursorStyle;
 		}
-		config.fullscreen.wheelScrollLines = normalizeFullscreenWheelScrollLines(
-			config.fullscreen.wheelScrollLines,
-			DEFAULT_CONFIG.fullscreen.wheelScrollLines,
-		);
 		if (typeof config.thinkingPeek !== "object" || config.thinkingPeek === null || Array.isArray(config.thinkingPeek)) {
 			config.thinkingPeek = structuredClone(DEFAULT_CONFIG.thinkingPeek);
 		} else {
 			config.thinkingPeek.lines = normalizeThinkingPeekLines(config.thinkingPeek.lines);
 		}
-		if (typeof config.inlineFooter !== "boolean") {
-			config.inlineFooter = DEFAULT_CONFIG.inlineFooter;
-		}
-		if (typeof config.roundedTools !== "boolean") {
-			config.roundedTools = DEFAULT_CONFIG.roundedTools;
-		}
 		return config;
 	} catch (err) {
 		notify?.(`pi-tui config parse error: ${err instanceof Error ? err.message : String(err)}`, "warning");

package/extensions/editor.ts

@@ -7,10 +7,6 @@ import {
 import type { EditorTheme, TuiMouseEvent, TuiMouseEventResult, TUI } from "@earendil-works/pi-tui";
 import { CURSOR_MARKER, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { CursorStyle } from "./config.ts";
-import {
-	applyFullscreenWheelScrollLines,
-	DEFAULT_FULLSCREEN_WHEEL_SCROLL_LINES,
-} from "./fullscreen-scroll.ts";
 import { findBottomBorderIndex, isEditorBorderLine, stripAnsi } from "./utils.ts";
 
 function fillLine(content: string, width: number): string {
@@ -316,14 +312,12 @@ export function installEditor(
 	_pi: ExtensionAPI,
 	ctx: ExtensionContext,
 	cursorStyle: CursorStyle = "block",
-	wheelScrollLines = DEFAULT_FULLSCREEN_WHEEL_SCROLL_LINES,
 	inlineFooter?: InlineFooterRenderer,
 ) {
 	let activeTui: TUI | undefined;
 	let activeEditor: OpenTuiEditor | undefined;
 	let previousHardwareCursor: boolean | undefined;
 	let currentCursorStyle = cursorStyle;
-	let currentWheelScrollLines = wheelScrollLines;
 	let hiddenThinkingTarget: HiddenThinkingLabelComponent | undefined;
 	const getActiveTui = (): TUI => {
 		if (!activeTui) throw new Error("Open TUI editor is not mounted");
@@ -333,7 +327,6 @@ export function installEditor(
 	ctx.ui.setEditorComponent((tui, editorTheme, keybindings) => {
 		activeTui = tui;
 		hiddenThinkingTarget = undefined;
-		applyFullscreenWheelScrollLines(tui, currentWheelScrollLines);
 		previousHardwareCursor = tui.getShowHardwareCursor();
 		activeEditor = new OpenTuiEditor(tui, editorTheme, keybindings, currentCursorStyle, inlineFooter);
 		return activeEditor;
@@ -359,10 +352,6 @@ export function installEditor(
 			currentCursorStyle = nextCursorStyle;
 			activeEditor?.setCursorStyle(nextCursorStyle, previousHardwareCursor);
 		},
-		setWheelScrollLines(nextWheelScrollLines: number): void {
-			currentWheelScrollLines = nextWheelScrollLines;
-			if (activeTui) applyFullscreenWheelScrollLines(activeTui, currentWheelScrollLines);
-		},
 		cleanup(): void {
 			hiddenThinkingTarget = undefined;
 			ctx.ui.setEditorComponent(undefined);

package/extensions/footer.ts

@@ -16,8 +16,9 @@ import {
 	formatCwd,
 	formatDuration,
 	formatInputBreakdown,
+	hasAnsiStyles,
 	providerColor,
-	sanitizeStatus,
+	sanitizeStatusPreservingStyles,
 	stressColor,
 	truncateBranch,
 	truncatePath,
@@ -181,6 +182,18 @@ function renderStatsBlock(
 	return stats.join(` ${theme.fg("dim", "|")} `);
 }
 
+const ANSI_RESET = "\x1b[0m";
+
+/**
+ * Keep the colours an extension applied to its own status text. Plain text stays
+ * muted so unstyled statuses keep the quiet footer look. The trailing reset
+ * stops an unclosed style from tinting the separator and the next status.
+ */
+function renderStatusText(theme: Theme, status: string): string {
+	if (!hasAnsiStyles(status)) return theme.fg("muted", status);
+	return `${status}${ANSI_RESET}`;
+}
+
 function renderExtensionStatusLines(
 	theme: Theme,
 	extensionStatuses: ReadonlyMap<string, string>,
@@ -189,12 +202,12 @@ function renderExtensionStatusLines(
 ): string[] {
 	const statuses = Array.from(extensionStatuses.entries())
 		.sort(([a], [b]) => a.localeCompare(b))
-		.map(([, text]) => sanitizeStatus(text))
+		.map(([, text]) => sanitizeStatusPreservingStyles(text))
 		.filter((text) => text.length > 0);
 	if (statuses.length === 0) return [];
 
 	const separator = ` ${theme.fg("dim", "|")} `;
-	const statusText = statuses.map((status) => theme.fg("muted", status)).join(separator);
+	const statusText = statuses.map((status) => renderStatusText(theme, status)).join(separator);
 	const line = `${theme.fg("mdLink", glyphs.extensions)} ${statusText}`;
 	return wrapTextWithAnsi(line, width);
 }

package/extensions/index.ts

@@ -4,7 +4,7 @@
  * thinking peek preview, rounded tool frames, and turn telemetry.
  *
  * Integrated from:
- *   - pi-open-tui (v0.3.10, MIT, by OldSun, https://github.com/OldSuns/pi-open-tui)
+ *   - pi-open-tui (v0.3.11, MIT, by OldSun, https://github.com/OldSuns/pi-open-tui)
  *   - pi-rounded-tools (v0.1.3, MIT, by OrionPax, https://github.com/orionpax1997/pi-rounded-tools)
  *
  * Security audit notes:
@@ -169,7 +169,6 @@ export default function (pi: ExtensionAPI) {
 				pi,
 				ctx,
 				config.cursorStyle,
-				config.fullscreen.wheelScrollLines,
 				{
 					enabled: () => config.inlineFooter,
 					render: footer.renderInline,
@@ -423,7 +422,6 @@ export default function (pi: ExtensionAPI) {
 			const wasEnabled = config.enabled;
 			const wasRoundedTools = config.roundedTools;
 			const cursorStyleChanged = config.cursorStyle !== newConfig.cursorStyle;
-			const wheelScrollLinesChanged = config.fullscreen.wheelScrollLines !== newConfig.fullscreen.wheelScrollLines;
 			const thinkingPeekLinesChanged = config.thinkingPeek.lines !== newConfig.thinkingPeek.lines;
 			saveConfig(newConfig);
 			config = newConfig;
@@ -436,9 +434,6 @@ export default function (pi: ExtensionAPI) {
 			if (cursorStyleChanged && active && editor) {
 				editor.setCursorStyle(newConfig.cursorStyle);
 			}
-			if (wheelScrollLinesChanged && active && editor) {
-				editor.setWheelScrollLines(newConfig.fullscreen.wheelScrollLines);
-			}
 			if (lastCtx) {
 				pendingUiChange = getPendingUiChange(newConfig.enabled, active);
 			}

package/extensions/rounded-tools.ts

@@ -4,7 +4,7 @@
  * Merged 2026-08 from the standalone local extension rounded-tools.ts (a
  * localized copy of npm:pi-rounded-tools@0.1.3, MIT, by OrionPax,
  * https://github.com/orionpax1997/pi-rounded-tools), integrated into pi-tui
- * (based on https://github.com/OldSuns/pi-open-tui v0.3.10, MIT, by
+ * (based on https://github.com/OldSuns/pi-open-tui v0.3.11, MIT, by
  * OldSun) and gated behind `roundedTools` in pi-tui config
  * (~/.pi/agent/pi-tui.json, default on).
  *
@@ -31,10 +31,11 @@ import {
 	createFindToolDefinition,
 	createGrepToolDefinition,
 	createLsToolDefinition,
+	createPowerShellToolDefinition,
 	createReadToolDefinition,
 	createWriteToolDefinition,
 } from "@earendil-works/pi-coding-agent";
-import type { Component } from "@earendil-works/pi-tui";
+import type { Component, TuiMouseEvent, TuiMouseEventResult } from "@earendil-works/pi-tui";
 import { visibleWidth } from "@earendil-works/pi-tui";
 
 // ─── Rounded-corner frame ────────────────────────────────────────────────
@@ -53,6 +54,10 @@ class RoundedFrame implements Component {
 		private readonly mode: FrameMode = "closed",
 	) {}
 
+	getInner(): Component {
+		return this.inner;
+	}
+
 	invalidate(): void {
 		this.inner.invalidate?.();
 		this.cachedWidth = undefined;
@@ -60,6 +65,32 @@ class RoundedFrame implements Component {
 		this.cachedLines = undefined;
 	}
 
+	handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+		if (!this.inner.handleMouse) return undefined;
+
+		const width = this.cachedWidth ?? event.width;
+		if (width < 4) {
+			return this.inner.handleMouse(event);
+		}
+
+		const innerWidth = Math.max(1, width - 4);
+		const paddingTop = this.mode !== "open-top" ? 1 : 0;
+		const contentX = event.x - 2;
+		const contentY = event.y - paddingTop;
+		const innerHeight = this.cachedInnerLines?.length ?? 0;
+
+		if (contentX < 0 || contentX >= innerWidth || contentY < 0 || contentY >= innerHeight) {
+			return undefined;
+		}
+
+		return this.inner.handleMouse({
+			...event,
+			x: contentX,
+			y: contentY,
+			width: innerWidth,
+		});
+	}
+
 	// pi's built-in tool renderers cache the previously-returned component
 	// via `context.lastComponent` and call mutating methods on it
 	// (`Text.setText`, `Container.clear`/`addChild`, `invalidate`) so they
@@ -177,8 +208,8 @@ const frame = (
 function borderColorFor(
 	context: { isPartial?: boolean; isError?: boolean } | undefined,
 ): string {
-	if (context?.isPartial) return "warning";
 	if (context?.isError) return "error";
+	if (context?.isPartial) return "warning";
 	return "border";
 }
 
@@ -189,81 +220,153 @@ type ToolDef = ToolDefinition<any, any, any>;
 const EMPTY_COMPONENT: Component = { render: () => [], invalidate: () => {} };
 
 /**
- * Wrap a built-in tool definition in rounded frames.
+ * Unwrap inner component from a RoundedFrame if context.lastComponent is wrapped,
+ * allowing underlying renderers (e.g. edit, bash, read) to preserve their component
+ * cache across renders instead of recreating on every tick.
+ */
+function unwrapInner(component: unknown): Component | undefined {
+	if (component instanceof RoundedFrame) {
+		return component.getInner();
+	}
+	return component as Component | undefined;
+}
+
+/**
+ * Wrap a tool definition in rounded frames.
  *
- * We spread the original definition first so we preserve every metadata
- * field (promptSnippet / promptGuidelines / prepareArguments /
- * constrainedSampling / executionMode / …) — only the renderers and
- * `renderShell` are overwritten. This keeps the tool's LLM-facing prompt
- * data intact, edit's argument pre-processing intact, etc.
+ * Preserves all metadata (promptSnippet, promptGuidelines, parameters, etc.)
+ * while wrapping renderCall and renderResult with rounded borders.
+ * Uses closed mode for tools without renderResult to avoid open bottom borders.
  */
 function wrapBuiltin(def: ToolDef) {
+	const callMode: FrameMode = def.renderResult ? "open-bottom" : "closed";
 	return {
 		...def,
 		renderShell: "self" as const,
 		renderCall: (args: any, theme: any, context: any) => {
-			// Hide our (or any) previous wrapper from the inner renderer so it
-			// doesn't treat a RoundedFrame as its own lastComponent — that
-			// would either throw (`Text.setText` is missing) or nest frames
-			// (`inner = previous RoundedFrame` → we re-wrap it). Forcing the
-			// inner to allocate fresh costs one Text/Container per render but
-			// keeps every render independent and CC-protect against future
-			// tool changes.
+			const unwrapped = unwrapInner(context?.lastComponent);
 			const inner: Component = def.renderCall
-				? def.renderCall(args, theme, { ...context, lastComponent: undefined })
+				? def.renderCall(args, theme, { ...context, lastComponent: unwrapped })
 				: EMPTY_COMPONENT;
-			// During execution pi re-renders every tick (e.g. bash's elapsed
-			// timer). Skip the frame then — keeping its borders stable avoids
-			// redraw flicker — and only wrap it once the tool settles.
-			if (context?.isPartial) return inner;
-			return frame(inner, theme, "open-bottom", borderColorFor(context));
+			return frame(inner, theme, callMode, borderColorFor(context));
 		},
 		renderResult: (result: any, options: any, theme: any, context: any) => {
+			const unwrapped = unwrapInner(context?.lastComponent);
 			const inner: Component = def.renderResult
-				? def.renderResult(result, options, theme, { ...context, lastComponent: undefined })
+				? def.renderResult(result, options, theme, { ...context, lastComponent: unwrapped })
 				: EMPTY_COMPONENT;
-			if (context?.isPartial) return inner;
 			return frame(inner, theme, "open-top", borderColorFor(context));
 		},
 	};
 }
 
 /**
- * Register the 7 built-in file/bash tools, either with rounded frames
- * (`enabled`) or with their plain stock definitions (`!enabled`, restores
- * original rendering). Registration refreshes the active tool set in the
- * current session, so toggling the setting takes effect immediately.
+ * Register built-in tools (read, write, edit, bash, powershell, grep, find, ls),
+ * either with rounded frames (`enabled`) or with stock definitions (`!enabled`).
+ *
+ * If a third-party extension has already replaced a built-in tool (e.g. pi-fff
+ * overriding grep/find), that tool is skipped here to prevent clobbering.
  */
-export function registerRoundedTools(pi: ExtensionAPI, enabled: boolean, cwd: string): void {
-	const tools: ToolDef[] = [
-		createReadToolDefinition(cwd),
-		createWriteToolDefinition(cwd),
-		createEditToolDefinition(cwd),
-		createBashToolDefinition(cwd),
-		createGrepToolDefinition(cwd),
-		createFindToolDefinition(cwd),
-		createLsToolDefinition(cwd),
-	];
-
-	for (const def of tools) {
-		pi.registerTool(enabled ? wrapBuiltin(def) : def);
+export function registerRoundedTools(
+	target: ExtensionAPI | ((tool: ToolDef) => void),
+	enabled: boolean,
+	cwd: string,
+	captured?: Map<string, ToolDef>,
+): void {
+	const register = typeof target === "function" ? target : target.registerTool.bind(target);
+
+	const builtins: Record<string, () => ToolDef> = {
+		read: () => createReadToolDefinition(cwd),
+		write: () => createWriteToolDefinition(cwd),
+		edit: () => createEditToolDefinition(cwd),
+		bash: () => createBashToolDefinition(cwd),
+		powershell: () => createPowerShellToolDefinition(cwd),
+		ls: () => createLsToolDefinition(cwd),
+		grep: () => createGrepToolDefinition(cwd),
+		find: () => createFindToolDefinition(cwd),
+	};
+
+	for (const [name, factory] of Object.entries(builtins)) {
+		if (!captured?.has(name)) {
+			register(enabled ? wrapBuiltin(factory()) : factory());
+		}
 	}
 }
 
 /**
  * Manager class encapsulating rounded tools registration and lifecycle updates.
+ *
+ * In addition to wrapping built-in tools, it installs a `pi.registerTool` proxy
+ * so that any tool registered by third-party extensions (e.g. pi-fff's ffgrep,
+ * fffind, fff-multi-grep, or overridden grep/find) automatically receives rounded
+ * frames when `roundedTools` is enabled, without maintaining a fragile hardcoded
+ * name whitelist.
+ *
+ * Load-order note: For extensions that register tools at load time, place
+ * `pi-tui-footer` before those packages in `~/.pi/agent/settings.json` so the
+ * proxy is active when they load.
  */
 export class RoundedToolsManager {
-	constructor(private readonly pi: ExtensionAPI) {}
+	private enabled = false;
+	private proxyInstalled = false;
+	/** The real `pi.registerTool` before we installed the proxy. */
+	private originalRegisterTool!: (tool: ToolDef) => void;
+	/** Original (unwrapped) definitions captured from third-party tools. */
+	private readonly captured = new Map<string, ToolDef>();
+
+	constructor(private readonly pi: ExtensionAPI) {
+		this.installProxy();
+	}
 
 	/** Register initial tools before session_start with fallback cwd. */
 	init(enabled: boolean, cwd = process.cwd()): void {
-		registerRoundedTools(this.pi, enabled, cwd);
+		this.enabled = enabled;
+		this.installProxy();
+		registerRoundedTools(this.originalRegisterTool, enabled, cwd, this.captured);
+		this.reRegisterCaptured();
 	}
 
 	/** Apply tools with current session cwd. */
 	apply(enabled: boolean, cwd: string): void {
-		registerRoundedTools(this.pi, enabled, cwd);
+		this.enabled = enabled;
+		this.installProxy();
+		registerRoundedTools(this.originalRegisterTool, enabled, cwd, this.captured);
+		this.reRegisterCaptured();
+	}
+
+	/**
+	 * Install a one-time proxy on `pi.registerTool` to intercept third-party
+	 * tool registrations.
+	 */
+	private installProxy(): void {
+		if (this.proxyInstalled) return;
+		this.proxyInstalled = true;
+
+		this.originalRegisterTool = this.pi.registerTool.bind(this.pi);
+		const original = this.originalRegisterTool;
+		const self = this;
+
+		this.pi.registerTool = function proxyRegisterTool(tool: ToolDef) {
+			// Don't intercept tools that already render their own shell
+			if (tool.renderShell === "self") {
+				original(tool);
+				return;
+			}
+
+			// Capture the unwrapped original definition
+			self.captured.set(tool.name, tool);
+			original(self.enabled ? wrapBuiltin(tool) : tool);
+		};
+	}
+
+	/**
+	 * Re-register all captured third-party tools with or without rounded
+	 * frames based on the current `enabled` state.
+	 */
+	private reRegisterCaptured(): void {
+		for (const def of this.captured.values()) {
+			this.originalRegisterTool(this.enabled ? wrapBuiltin(def) : def);
+		}
 	}
 }
 

package/extensions/settings-command.ts

@@ -1,7 +1,6 @@
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import {
 	Box,
-	Input,
 	Key,
 	matchesKey,
 	SelectList,
@@ -11,10 +10,6 @@ import {
 	Text,
 } from "@earendil-works/pi-tui";
 import type { CursorStyle, IconMode, OpenTuiConfig, SettingsLanguage, ThinkingPeekLines } from "./config.ts";
-import {
-	DEFAULT_FULLSCREEN_WHEEL_SCROLL_LINES,
-	normalizeFullscreenWheelScrollLines,
-} from "./fullscreen-scroll.ts";
 
 interface SettingItem {
 	id: string;
@@ -30,14 +25,13 @@ const COPY = {
 	en: {
 		title: "Pi TUI Settings",
 		tabs: { features: "General", icons: "Appearance", segments: "Footer", telemetry: "Telemetry" },
-		hint: "Tab/Shift+Tab/←/→: tabs · ↑/↓: move · Enter/Space: change · Enter on wheel speed: type 1-10 · Esc/q: close",
+		hint: "Tab/Shift+Tab/←/→: tabs · ↑/↓: move · Enter/Space: change · Esc/q: close",
 		labels: {
 			enabled: "Enabled",
 			roundedTools: "Rounded tool frames",
 			inlineFooter: "Inline footer",
 			thinkingPeek: "Thinking peek",
 			language: "Language",
-			wheelScrollLines: "Mouse wheel speed",
 			cursorStyle: "Cursor style",
 			iconMode: "Icon mode",
 			cwd: "CWD",
@@ -62,8 +56,6 @@ const COPY = {
 			off: "Off",
 			thinkingPeek: { off: "Off", one: "1 line", two: "2 lines" },
 			languages: { en: "English", zh: "简体中文" },
-			wheelLines: (count: number) => `${count} ${count === 1 ? "line" : "lines"} / notch`,
-			wheelPrompt: (count: number) => `Wheel scroll lines per notch, 1-10 (current: ${count}). Enter: apply · Esc: cancel`,
 			cursorStyles: { block: "Block", bar: "Bar", underline: "Underline" },
 			icons: { auto: "Auto", nerd: "Nerd", unicode: "Unicode", ascii: "ASCII" },
 		},
@@ -71,14 +63,13 @@ const COPY = {
 	zh: {
 		title: "Pi TUI 设置",
 		tabs: { features: "常规", icons: "外观", segments: "Footer", telemetry: "遥测" },
-		hint: "Tab/Shift+Tab/←/→：切页 · ↑/↓：移动 · Enter/Space：更改 · 滚轮速度项 Enter 输入 1-10 · Esc/q：关闭",
+		hint: "Tab/Shift+Tab/←/→：切页 · ↑/↓：移动 · Enter/Space：更改 · Esc/q：关闭",
 		labels: {
 			enabled: "启用",
 			roundedTools: "圆角工具边框",
 			inlineFooter: "内联底栏",
 			thinkingPeek: "思考预览",
 			language: "语言",
-			wheelScrollLines: "鼠标滚轮速度",
 			cursorStyle: "光标样式",
 			iconMode: "图标模式",
 			cwd: "当前目录",
@@ -103,8 +94,6 @@ const COPY = {
 			off: "关闭",
 			thinkingPeek: { off: "关闭", one: "单行", two: "双行" },
 			languages: { en: "English", zh: "简体中文" },
-			wheelLines: (count: number) => `每格 ${count} 行`,
-			wheelPrompt: (count: number) => `滚轮每格滚动行数（当前 ${count}，范围 1-10），输入后 Enter 应用 · Esc 取消`,
 			cursorStyles: { block: "块", bar: "竖线", underline: "下划线" },
 			icons: { auto: "自动", nerd: "Nerd", unicode: "Unicode", ascii: "ASCII" },
 		},
@@ -150,19 +139,6 @@ function cycleCursorStyle(config: OpenTuiConfig): OpenTuiConfig {
 	return { ...config, cursorStyle: next };
 }
 
-function setWheelScrollLines(config: OpenTuiConfig, raw: string): OpenTuiConfig | undefined {
-	if (!/^\d+$/.test(raw)) return undefined;
-	const parsed = Number(raw);
-	const bounded = Number.isFinite(parsed) ? parsed : Number.MAX_SAFE_INTEGER;
-	return {
-		...config,
-		fullscreen: {
-			...config.fullscreen,
-			wheelScrollLines: normalizeFullscreenWheelScrollLines(bounded, DEFAULT_FULLSCREEN_WHEEL_SCROLL_LINES),
-		},
-	};
-}
-
 function toggleTelemetry(config: OpenTuiConfig, key: keyof OpenTuiConfig["telemetry"]): OpenTuiConfig {
 	return {
 		...config,
@@ -184,11 +160,6 @@ function buildFeaturesItems(config: OpenTuiConfig, copy: SettingsCopy): SettingI
 		{ id: "enabled", label: copy.labels.enabled, currentValue: flag(config.enabled) },
 		{ id: "roundedTools", label: copy.labels.roundedTools, currentValue: flag(config.roundedTools) },
 		{ id: "settingsLanguage", label: copy.labels.language, currentValue: copy.values.languages[config.settingsLanguage] },
-		{
-			id: "wheelScrollLines",
-			label: copy.labels.wheelScrollLines,
-			currentValue: copy.values.wheelLines(config.fullscreen.wheelScrollLines),
-		},
 		{ id: "thinkingPeek", label: copy.labels.thinkingPeek, currentValue: formatThinkingPeekLines(config.thinkingPeek.lines, copy) },
 		{ id: "inlineFooter", label: copy.labels.inlineFooter, currentValue: flag(config.inlineFooter) },
 	];
@@ -275,23 +246,6 @@ interface SettingsUiHandle {
 	handleInput: (data: string) => void;
 }
 
-function insertComponentAfter(list: Component, child: Component, index: () => number): Component {
-	// SelectList renders one line per item; splice the editor into that output.
-	return {
-		render(width: number): string[] {
-			const lines = list.render(width);
-			const insertAt = index();
-			if (insertAt < 0 || insertAt >= lines.length) return lines;
-			const childLines = child.render(width);
-			return [...lines.slice(0, insertAt + 1), ...childLines, ...lines.slice(insertAt + 1)];
-		},
-		invalidate(): void {
-			list.invalidate();
-			child.invalidate();
-		},
-	};
-}
-
 class SettingsUi implements SettingsUiHandle {
 	private tab: Tab = "features";
 	private config: OpenTuiConfig;
@@ -304,7 +258,6 @@ class SettingsUi implements SettingsUiHandle {
 	private cachedWidth: number | undefined;
 	private cachedLines: string[] | undefined;
 	private compact = false;
-	private wheelInput: Input | undefined;
 
 	constructor(
 		theme: Theme,
@@ -329,35 +282,11 @@ class SettingsUi implements SettingsUiHandle {
 
 	private applySetting(itemId: string): void {
 		this.selectedItemByTab[this.tab] = itemId;
-		if (this.tab === "features" && itemId === "wheelScrollLines") {
-			this.openWheelInput();
-			this.invalidate();
-			return;
-		}
 		this.config = handleSettingChange(this.tab, itemId, this.config);
 		this.onChange(this.config);
 		this.rebuild(itemId);
 	}
 
-	private openWheelInput(): void {
-		const input = new Input();
-		input.onSubmit = (value) => {
-			const next = setWheelScrollLines(this.config, value);
-			this.wheelInput = undefined;
-			if (next) {
-				this.config = next;
-				this.onChange(this.config);
-			}
-			this.rebuild("wheelScrollLines");
-		};
-		input.onEscape = () => {
-			this.wheelInput = undefined;
-			this.rebuild("wheelScrollLines");
-		};
-		this.wheelInput = input;
-		this.rebuild("wheelScrollLines");
-	}
-
 	private switchTab(offset: number): void {
 		const idx = TABS.indexOf(this.tab);
 		this.tab = TABS[(idx + offset + TABS.length) % TABS.length]!;
@@ -377,17 +306,11 @@ class SettingsUi implements SettingsUiHandle {
 		this.container.addChild(new Text(tabBar, 1, 0));
 		this.container.addChild(new Text(this.theme.fg("dim", copy.hint), 1, 0));
 
-		const editingWheel = this.tab === "features" && this.wheelInput !== undefined;
-		const items = buildItems(this.tab, this.config).map((item) => {
-			const editing = editingWheel && item.id === "wheelScrollLines";
-			return {
-				value: item.id,
-				label: editing
-					? (this.compact ? `${item.label}:` : item.label)
-					: (this.compact ? `${item.label}: ${item.currentValue}` : item.label),
-				description: editing || this.compact ? undefined : item.currentValue,
-			} as SelectItem;
-		});
+		const items = buildItems(this.tab, this.config).map((item) => ({
+			value: item.id,
+			label: this.compact ? `${item.label}: ${item.currentValue}` : item.label,
+			description: this.compact ? undefined : item.currentValue,
+		} as SelectItem));
 		this.selectList = new SelectList(items, Math.min(items.length, 12), {
 			selectedPrefix: (t) => this.theme.fg("accent", t),
 			selectedText: (t) => this.theme.fg("accent", t),
@@ -409,31 +332,13 @@ class SettingsUi implements SettingsUiHandle {
 		this.selectList.onCancel = () => {
 			this.onClose();
 		};
-		if (editingWheel) {
-			this.wheelInput!.focused = true;
-			const wheelInputGroup = new Box(4, 0);
-			wheelInputGroup.addChild(new Text(
-				this.theme.fg("muted", copy.values.wheelPrompt(this.config.fullscreen.wheelScrollLines)),
-				0,
-				0,
-			));
-			wheelInputGroup.addChild(this.wheelInput!);
-			const selectedIndex = () => items.findIndex((item) => item.value === this.selectList.getSelectedItem()?.value);
-			this.container.addChild(insertComponentAfter(this.selectList, wheelInputGroup, selectedIndex));
-		} else {
-			this.container.addChild(this.selectList);
-		}
+		this.container.addChild(this.selectList);
 
 		this.cachedWidth = undefined;
 		this.cachedLines = undefined;
 	}
 
 	handleInput(data: string): void {
-		if (this.wheelInput && this.tab === "features") {
-			this.wheelInput.handleInput(data);
-			this.invalidate();
-			return;
-		}
 		if (matchesKey(data, Key.tab) || matchesKey(data, Key.right)) {
 			this.switchTab(1);
 			this.invalidate();

package/extensions/utils.ts

@@ -296,6 +296,28 @@ export function sanitizeStatus(text: string): string {
 		.trim();
 }
 
+// One status token is an SGR sequence, another escape sequence, or one control
+// character. SGR carries colours. Everything else moves the cursor or rewrites
+// the terminal, so it must never reach the footer row.
+const STATUS_TOKEN = /(?:\x1b\[|\x9b)[0-?]*[ -/]*m|(?:\x1b\[|\x9b)[0-?]*[ -/]*[@-~]|(?:\x1bP|\x90|\x1bX|\x98|\x1b\^|\x9e|\x1b_|\x9f)[\s\S]*?(?:\x1b\\|\x9c|$)|(?:\x1b\]|\x9d)[\s\S]*?(?:\x07|\x1b\\|\x9c|$)|\x1b[@-Z\\_]|[\u0000-\u001f\u007f-\u009f]/g;
+const SGR_TOKEN = /^(?:\x1b\[|\x9b)[0-9;:]*m$/;
+const SGR_SEQUENCE = /(?:\x1b\[|\x9b)[0-9;:]*m/;
+
+/**
+ * Sanitize a status text the same way {@link sanitizeStatus} does, but keep the
+ * SGR sequences the extension set. Extensions colour their own status text with
+ * `ctx.ui.theme.fg()`. Stripping those codes renders every status grey.
+ */
+export function sanitizeStatusPreservingStyles(text: string): string {
+	const cleaned = text.replace(STATUS_TOKEN, (token) => (SGR_TOKEN.test(token) ? token : " "));
+	return cleaned.replace(/ {2,}/g, " ").trim();
+}
+
+/** True when the text carries SGR colour or style sequences. */
+export function hasAnsiStyles(text: string): boolean {
+	return SGR_SEQUENCE.test(text);
+}
+
 export function formatThinkingLabel(level: string): string {
 	if (level === "off") return "thinking off";
 	return `${level} effort`;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-tui-footer",
-	"version": "1.2.5",
+	"version": "1.2.7",
 	"description": "pi extension: TUI footer/header with git status, telemetry, rounded tools, editor and settings enhancements",
 	"type": "module",
 	"keywords": [

package/extensions/fullscreen-scroll.ts

@@ -1,34 +0,0 @@
-import type { TUI } from "@earendil-works/pi-tui";
-
-export const MIN_FULLSCREEN_WHEEL_SCROLL_LINES = 1;
-export const MAX_FULLSCREEN_WHEEL_SCROLL_LINES = 10;
-export const DEFAULT_FULLSCREEN_WHEEL_SCROLL_LINES = 4;
-
-export function normalizeFullscreenWheelScrollLines(
-	value: unknown,
-	fallback = DEFAULT_FULLSCREEN_WHEEL_SCROLL_LINES,
-): number {
-	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
-	return Math.min(
-		MAX_FULLSCREEN_WHEEL_SCROLL_LINES,
-		Math.max(MIN_FULLSCREEN_WHEEL_SCROLL_LINES, Math.floor(value)),
-	);
-}
-
-type FullscreenWheelTui = TUI & { wheelScrollLines?: unknown };
-
-/**
- * Pi 0.84.2 keeps this constructor option in a private runtime field. Remove
- * this shim once Pi exposes a public setter; incompatible versions are no-ops.
- */
-export function applyFullscreenWheelScrollLines(tui: TUI, value: number): boolean {
-	try {
-		const fullscreenTui = tui as FullscreenWheelTui;
-		if (fullscreenTui.mode !== "fullscreen" || typeof fullscreenTui.wheelScrollLines !== "number") {
-			return false;
-		}
-		return Reflect.set(fullscreenTui, "wheelScrollLines", normalizeFullscreenWheelScrollLines(value));
-	} catch {
-		return false;
-	}
-}