pi-tui-footer 1.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 onenora
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# pi-tui-footer
+
+pi 插件：TUI 美化套件 — 动画 Pi logo 头部、Starship 风格底部状态栏、圆角编辑器、圆角工具框、回合遥测（TPS/TTFT/耗时/token/费用）。
+
+## 安装
+
+```bash
+pi install git:github.com/onenora/pi-tui-footer
+```
+
+固定版本：
+
+```bash
+pi install git:github.com/onenora/pi-tui-footer@v1.2.0
+```
+
+更新：
+
+```bash
+pi update --extensions
+```
+
+## 配置
+
+配置文件位于 `~/.pi/agent/pi-tui.json`，示例：
+
+```json
+{
+  "enabled": true,
+  "roundedTools": true,
+  "settingsLanguage": "zh",
+  "cursorStyle": "underline",
+  "fullscreen": { "wheelScrollLines": 4 },
+  "icons": { "mode": "nerd" }
+}
+```
+
+也可在 pi 内通过 `/pi-tui` 命令调整。
+
+## 致谢
+
+本项目是以下两个开源项目的深度融合集成：
+
+- [pi-open-tui](https://github.com/OldSuns/pi-open-tui) — 头部、底部、编辑器、遥测和设置界面的整体结构
+- [pi-rounded-tools](https://github.com/orionpax1997/pi-rounded-tools) — 圆角工具调用/结果框
+
+## 结构
+
+- `extensions/` — 全部插件源码（TypeScript，pi 直接加载）
+- `LICENSE` — MIT 许可证
+
+仅依赖 pi 内置模块（`@earendil-works/pi-*` peer）与 Node 内置模块，无第三方运行时依赖。
+
+## License
+
+[MIT](LICENSE)

package/extensions/config.ts

@@ -0,0 +1,196 @@
+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";
+export type CursorStyle = "block" | "bar" | "underline";
+export type ThinkingPeekLines = 0 | 1 | 2;
+
+export type { IconMode } from "./icons.ts";
+
+export interface FooterSegments {
+	cwd: boolean;
+	hostname: boolean;
+	sessionName: boolean;
+	gitBranch: boolean;
+	gitStatus: boolean;
+	gitCommit: boolean;
+	runtime: boolean;
+	context: boolean;
+	tokens: boolean;
+	cost: boolean;
+	extensionStatuses: boolean;
+	capitalizeProviderName: boolean;
+}
+
+export interface TelemetryConfig {
+	enabled: boolean;
+	tps: boolean;
+	ttft: boolean;
+	duration: boolean;
+	tokens: boolean;
+	stalls: boolean;
+	cost: boolean;
+}
+
+export interface ThinkingPeekConfig {
+	lines: ThinkingPeekLines;
+}
+
+export interface FullscreenConfig {
+	wheelScrollLines: number;
+}
+
+export interface OpenTuiConfig {
+	enabled: boolean;
+	roundedTools: boolean;
+	settingsLanguage: SettingsLanguage;
+	cursorStyle: CursorStyle;
+	fullscreen: FullscreenConfig;
+	icons: {
+		mode: IconMode;
+	};
+	footerSegments: FooterSegments;
+	telemetry: TelemetryConfig;
+	thinkingPeek: ThinkingPeekConfig;
+}
+
+export type PiTuiConfig = OpenTuiConfig;
+
+export const DEFAULT_CONFIG: OpenTuiConfig = {
+	enabled: true,
+	roundedTools: true,
+	settingsLanguage: "en",
+	cursorStyle: "block",
+	fullscreen: {
+		wheelScrollLines: DEFAULT_FULLSCREEN_WHEEL_SCROLL_LINES,
+	},
+	icons: {
+		mode: "auto",
+	},
+	footerSegments: {
+		cwd: true,
+		hostname: false,
+		sessionName: false,
+		gitBranch: true,
+		gitStatus: true,
+		gitCommit: false,
+		runtime: true,
+		context: true,
+		tokens: true,
+		cost: true,
+		extensionStatuses: true,
+		capitalizeProviderName: true,
+	},
+	telemetry: {
+		enabled: true,
+		tps: true,
+		ttft: true,
+		duration: true,
+		tokens: true,
+		stalls: true,
+		cost: true,
+	},
+	thinkingPeek: {
+		lines: 1,
+	},
+};
+
+export function getConfigPath(): string {
+	const agentDir = getAgentDir();
+	const piTuiPath = join(agentDir, "pi-tui.json");
+	const openTuiPath = join(agentDir, "open-tui.json");
+	if (existsSync(piTuiPath)) return piTuiPath;
+	if (existsSync(openTuiPath)) return openTuiPath;
+	return piTuiPath;
+}
+
+function normalizeThinkingPeekLines(value: unknown): ThinkingPeekLines {
+	return value === 0 || value === 1 || value === 2 ? value : DEFAULT_CONFIG.thinkingPeek.lines;
+}
+
+function deepMerge<T>(base: T, override: unknown): T {
+	if (typeof base !== "object" || base === null || Array.isArray(base)) {
+		return (override as T) ?? base;
+	}
+	if (typeof override !== "object" || override === null || Array.isArray(override)) {
+		return base;
+	}
+	const result = { ...(base as Record<string, unknown>) };
+	const overrideRec = override as Record<string, unknown>;
+	for (const key of Object.keys(overrideRec)) {
+		const baseVal = (base as Record<string, unknown>)[key];
+		const overVal = overrideRec[key];
+		if (typeof baseVal === "object" && baseVal !== null && !Array.isArray(baseVal)
+			&& typeof overVal === "object" && overVal !== null && !Array.isArray(overVal)) {
+			result[key] = deepMerge(baseVal, overVal);
+		} else if (overVal !== undefined) {
+			result[key] = overVal;
+		}
+	}
+	return result as T;
+}
+
+export function ensureConfigExists(): void {
+	const path = getConfigPath();
+	if (existsSync(path)) return;
+	try {
+		const agentDir = getAgentDir();
+		if (!existsSync(agentDir)) mkdirSync(agentDir, { recursive: true });
+		writeFileSync(path, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n", "utf8");
+	} catch {
+		// ponytail: silent fallback — config creation is best-effort
+	}
+}
+
+export function loadConfig(notify?: (msg: string, level: "warning" | "info") => void): OpenTuiConfig {
+	const path = getConfigPath();
+	if (!existsSync(path)) {
+		ensureConfigExists();
+		return structuredClone(DEFAULT_CONFIG);
+	}
+
+	try {
+		const raw = readFileSync(path, "utf8");
+		const parsed: unknown = JSON.parse(raw);
+		const config = deepMerge(DEFAULT_CONFIG, parsed);
+		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.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");
+		return structuredClone(DEFAULT_CONFIG);
+	}
+}
+
+export function saveConfig(config: OpenTuiConfig): void {
+	const path = getConfigPath();
+	try {
+		const agentDir = getAgentDir();
+		if (!existsSync(agentDir)) mkdirSync(agentDir, { recursive: true });
+		writeFileSync(path, JSON.stringify(config, null, 2) + "\n", "utf8");
+	} catch {
+		// ponytail: silent fallback — config save is best-effort
+	}
+}

package/extensions/editor.ts

@@ -0,0 +1,295 @@
+import {
+	CustomEditor,
+	type ExtensionAPI,
+	type ExtensionContext,
+	type KeybindingsManager,
+} from "@earendil-works/pi-coding-agent";
+import type { EditorTheme, 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 {
+	const truncated = truncateToWidth(content, Math.max(0, width), "");
+	const pad = " ".repeat(Math.max(0, width - visibleWidth(truncated)));
+	return `${truncated}${pad}`;
+}
+
+const CURSOR_STYLE_SEQUENCES: Partial<Record<CursorStyle, string>> = {
+	bar: "\x1b[6 q",
+	underline: "\x1b[4 q",
+};
+const DEFAULT_CURSOR_STYLE_SEQUENCE = "\x1b[0 q";
+
+interface WorkingStatusIndicator {
+	renderInBorder(width: number): string;
+	renderSpinnerInBorder(width: number): string;
+}
+
+interface HiddenThinkingLabelComponent {
+	children: unknown[];
+	setHiddenThinkingLabel(label: string): void;
+	setHideThinkingBlock(hide: boolean): void;
+	updateContent(message: unknown, isStreaming?: boolean): void;
+}
+
+function isHiddenThinkingLabelComponent(value: object): value is HiddenThinkingLabelComponent {
+	const component = value as unknown as Record<string, unknown>;
+	return Array.isArray(component.children)
+		&& typeof component.setHiddenThinkingLabel === "function"
+		&& typeof component.setHideThinkingBlock === "function"
+		&& typeof component.updateContent === "function";
+}
+
+/** Ponytail until Pi exposes a per-message hidden-thinking label API. */
+function findLatestHiddenThinkingLabel(tui: TUI): HiddenThinkingLabelComponent {
+	const pending: unknown[] = [tui];
+	const visited = new Set<object>();
+	let latest: HiddenThinkingLabelComponent | undefined;
+	while (pending.length > 0) {
+		const value = pending.pop();
+		if (!value || typeof value !== "object" || visited.has(value)) continue;
+		visited.add(value);
+		if (isHiddenThinkingLabelComponent(value)) latest = value;
+		const children = (value as { children?: unknown }).children;
+		if (!Array.isArray(children)) continue;
+		for (let i = children.length - 1; i >= 0; i--) pending.push(children[i]);
+	}
+	if (!latest) throw new Error("Unable to find the active hidden-thinking component");
+	return latest;
+}
+
+function removeSoftwareCursor(line: string, cursorMarker = ""): string {
+	return line.replace(/\x1b\[7m([\s\S]*?)\x1b\[0m/g, (_match, cursor: string) => {
+		const replacement = `${cursorMarker}${cursor}`;
+		cursorMarker = "";
+		return replacement;
+	});
+}
+
+function configureCursor(tui: TUI, cursorStyle: CursorStyle): void {
+	if (cursorStyle === "block") return;
+	tui.setShowHardwareCursor(true);
+	const sequence = CURSOR_STYLE_SEQUENCES[cursorStyle];
+	if (sequence) tui.terminal.write(sequence);
+}
+
+function roundedBorder(
+	width: number,
+	kind: "top" | "bottom",
+	paint: (s: string) => string,
+	sourceLine?: string,
+	indicator?: WorkingStatusIndicator,
+): string {
+	if (width < 2) return paint(truncateToWidth(kind === "top" ? "╭╮" : "╰╯", width, ""));
+	const corners = kind === "top" ? (["╭", "╮"] as const) : (["╰", "╯"] as const);
+
+	if (kind === "top" && indicator) {
+		const plain = sourceLine ? stripAnsi(sourceLine) : "";
+		const scrollMatch = plain.match(/([↑↓]\s+\d+\s+more)/);
+		const contentWidth = width - 2;
+		let status = indicator.renderInBorder(Math.max(1, contentWidth - 5));
+		let statusWidth = visibleWidth(status);
+		if (statusWidth > 0) {
+			const overflowLabel = scrollMatch ? ` ${scrollMatch[1]} ` : undefined;
+			const overflowLabelWidth = overflowLabel ? visibleWidth(overflowLabel) : 0;
+			const overflowStart = Math.floor((contentWidth - overflowLabelWidth) / 2);
+			const canFitOverflow = () => overflowLabel !== undefined
+				&& overflowLabelWidth + 2 <= contentWidth
+				&& overflowStart - (3 + statusWidth + 1) >= 1;
+			if (overflowLabel && !canFitOverflow()) {
+				status = indicator.renderSpinnerInBorder(contentWidth);
+				statusWidth = visibleWidth(status);
+			}
+			if (canFitOverflow()) {
+				const leftBlockWidth = 3 + statusWidth + 1;
+				return `${paint(`${corners[0]}── `)}${status}${paint(` ${"─".repeat(overflowStart - leftBlockWidth)}${overflowLabel}${"─".repeat(contentWidth - overflowStart - overflowLabelWidth)}${corners[1]}`)}`;
+			}
+			if (contentWidth >= statusWidth + 5) {
+				return `${paint(`${corners[0]}── `)}${status}${paint(` ${"─".repeat(contentWidth - statusWidth - 4)}${corners[1]}`)}`;
+			}
+			status = indicator.renderSpinnerInBorder(contentWidth);
+			statusWidth = visibleWidth(status);
+			const prefixWidth = Math.min(3, Math.max(0, contentWidth - statusWidth));
+			return `${paint(`${corners[0]}${"─".repeat(prefixWidth)}`)}${status}${paint(`${"─".repeat(Math.max(0, contentWidth - prefixWidth - statusWidth))}${corners[1]}`)}`;
+		}
+	}
+
+	if (sourceLine) {
+		const plain = stripAnsi(sourceLine);
+		const scrollMatch = plain.match(/([↑↓]\s+\d+\s+more)/);
+		if (scrollMatch) {
+			const label = `─── ${scrollMatch[1]} `;
+			const fill = Math.max(0, width - 2 - visibleWidth(label));
+			return paint(`${corners[0]}${label}${"─".repeat(fill)}${corners[1]}`);
+		}
+	}
+
+	return paint(`${corners[0]}${"─".repeat(Math.max(0, width - 2))}${corners[1]}`);
+}
+
+export class OpenTuiEditor extends CustomEditor {
+	readonly embedWorkingStatus = true;
+	private readonly getRail: () => string;
+	private readonly getBorder: (s: string) => string;
+	private embeddedWorkingStatusIndicator: WorkingStatusIndicator | undefined;
+	private cursorStyle: CursorStyle;
+	private previewHardwareCursor = false;
+
+	constructor(
+		tui: TUI,
+		editorTheme: EditorTheme,
+		keybindings: KeybindingsManager,
+		cursorStyle: CursorStyle = "block",
+	) {
+		super(tui, editorTheme, keybindings, { paddingX: 0 });
+		this.cursorStyle = cursorStyle;
+		configureCursor(tui, cursorStyle);
+		// ponytail: route the frame through this.borderColor so Pi can recolor it
+		// via updateEditorBorderColor() — bash mode ("! " prefix → green) and
+		// thinking-level borders both flow through this one property.
+		this.getRail = () => this.borderColor("│");
+		this.getBorder = (s: string) => this.borderColor(s);
+	}
+
+	override setPaddingX(_padding: number): void {
+		// The custom rail owns the horizontal inset and keeps one stable text gap.
+		super.setPaddingX(0);
+	}
+
+	setWorkingStatusIndicator(indicator: WorkingStatusIndicator | undefined): void {
+		this.embeddedWorkingStatusIndicator = indicator;
+		this.tui.requestRender();
+	}
+
+	setCursorStyle(cursorStyle: CursorStyle, blockHardwareCursor = false): void {
+		const styleChanged = cursorStyle !== this.cursorStyle;
+		this.previewHardwareCursor = cursorStyle !== "block";
+		this.cursorStyle = cursorStyle;
+		if (styleChanged) {
+			if (cursorStyle === "block") {
+				this.tui.terminal.write(DEFAULT_CURSOR_STYLE_SEQUENCE);
+				this.tui.setShowHardwareCursor(blockHardwareCursor);
+			} else {
+				configureCursor(this.tui, cursorStyle);
+			}
+		}
+		this.tui.requestRender();
+	}
+
+	private renderBase(width: number): string[] {
+		const renderedLines = super.render(width);
+		if (this.cursorStyle === "block") return renderedLines;
+
+		// Pi re-applies settings.showHardwareCursor after session_start (/reload,
+		// /new, session switches). Non-block styles have no software cursor left to
+		// fall back on, so re-assert the hardware cursor instead of losing it.
+		if (!this.tui.getShowHardwareCursor()) configureCursor(this.tui, this.cursorStyle);
+
+		// A focused overlay suppresses the editor's cursor marker. Preserve its
+		// position only for the live settings preview, then clear it on refocus.
+		let cursorMarker = this.previewHardwareCursor && !this.focused ? CURSOR_MARKER : "";
+		if (this.focused) this.previewHardwareCursor = false;
+		return renderedLines.map((line) => {
+			const rendered = removeSoftwareCursor(line, cursorMarker);
+			if (rendered !== line) cursorMarker = "";
+			return rendered;
+		});
+	}
+
+	render(width: number): string[] {
+		if (width < 4) return this.renderBase(width);
+
+		const rail = this.getRail();
+		const borderPaint = this.getBorder;
+		// ponytail: 1-char rail + 1-char gap on each side = 4 chars of chrome.
+		const innerWidth = Math.max(0, width - 4);
+		const baseLines = this.renderBase(innerWidth);
+		const bottomIdx = findBottomBorderIndex(baseLines);
+
+		const result: string[] = [];
+		result.push(roundedBorder(width, "top", borderPaint, baseLines[0], this.embeddedWorkingStatusIndicator));
+
+		for (let i = 1; i < bottomIdx; i++) {
+			const line = baseLines[i] ?? "";
+			if (isEditorBorderLine(line)) {
+				result.push(`${rail} ${fillLine("", innerWidth)} ${rail}`);
+			} else {
+				result.push(`${rail} ${fillLine(line, innerWidth)} ${rail}`);
+			}
+		}
+
+		result.push(roundedBorder(width, "bottom", borderPaint, baseLines[bottomIdx]));
+
+		for (let i = bottomIdx + 1; i < baseLines.length; i++) {
+			result.push(baseLines[i]!);
+		}
+
+		return result.map((line) => truncateToWidth(line, width, ""));
+	}
+}
+
+export function installEditor(
+	_pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	cursorStyle: CursorStyle = "block",
+	wheelScrollLines = DEFAULT_FULLSCREEN_WHEEL_SCROLL_LINES,
+) {
+	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");
+		return activeTui;
+	};
+
+	ctx.ui.setEditorComponent((tui, editorTheme, keybindings) => {
+		activeTui = tui;
+		hiddenThinkingTarget = undefined;
+		applyFullscreenWheelScrollLines(tui, currentWheelScrollLines);
+		previousHardwareCursor = tui.getShowHardwareCursor();
+		activeEditor = new OpenTuiEditor(tui, editorTheme, keybindings, currentCursorStyle);
+		return activeEditor;
+	});
+	return {
+		getViewportWidth(): number {
+			const columns = getActiveTui().terminal.columns;
+			if (typeof columns !== "number" || !Number.isFinite(columns)) {
+				throw new Error("Open TUI editor terminal has an invalid width");
+			}
+			return Math.max(1, Math.floor(columns));
+		},
+		setLatestHiddenThinkingLabel(label: string): void {
+			const tui = getActiveTui();
+			hiddenThinkingTarget ??= findLatestHiddenThinkingLabel(tui);
+			hiddenThinkingTarget.setHiddenThinkingLabel(label);
+			tui.requestRender();
+		},
+		resetHiddenThinkingLabelTarget(): void {
+			hiddenThinkingTarget = undefined;
+		},
+		setCursorStyle(nextCursorStyle: CursorStyle): void {
+			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);
+			if (activeTui) {
+				if (currentCursorStyle !== "block") activeTui.terminal.write(DEFAULT_CURSOR_STYLE_SEQUENCE);
+				if (previousHardwareCursor !== undefined) activeTui.setShowHardwareCursor(previousHardwareCursor);
+			}
+		},
+	};
+}