@yinan_chen/pi-claude-code-ui 0.0.0-stage → 0.2.1

package/src/vendor/diff/line-width-safety.ts

@@ -0,0 +1,92 @@
+import { normalizeDiffRenderWidth } from "./diff-presentation.ts";
+import { pluralize } from "./diff-text.ts";
+import { showMoreHintText } from "../show-more-hint.ts";
+
+export interface WidthMeasurementOps {
+	measure(text: string): number;
+	truncate(text: string, maxWidth: number): string;
+}
+
+export interface CollapsedDiffHintOptions {
+	remainingLines: number;
+	hiddenHunks: number;
+}
+
+function guardSafeWidth(width: number): number | undefined {
+	const safe = normalizeDiffRenderWidth(width);
+	return safe === 0 ? undefined : safe;
+}
+
+function renderWithSafeWidth<T>(width: number, fallback: T, render: (safeWidth: number) => T): T {
+	const safeWidth = guardSafeWidth(width);
+	if (safeWidth === undefined) {
+		return fallback;
+	}
+	return render(safeWidth);
+}
+
+export function clampRenderedLineToWidth(
+	text: string,
+	width: number,
+	ops: WidthMeasurementOps,
+): string {
+	return renderWithSafeWidth(width, "", (safeWidth) => {
+		if (ops.measure(text) <= safeWidth) {
+			return text;
+		}
+
+		for (let targetWidth = safeWidth; targetWidth >= 0; targetWidth--) {
+			const candidate = ops.truncate(text, targetWidth);
+			if (ops.measure(candidate) <= safeWidth) {
+				return candidate;
+			}
+		}
+
+		return "";
+	});
+}
+
+export function clampRenderedLinesToWidth(
+	lines: string[],
+	width: number,
+	ops: WidthMeasurementOps,
+): string[] {
+	return lines.map((line) => clampRenderedLineToWidth(line, width, ops));
+}
+
+export function buildCollapsedDiffHintText(
+	options: CollapsedDiffHintOptions,
+	width: number,
+	ops: WidthMeasurementOps,
+): string {
+	return renderWithSafeWidth(width, "", (safeWidth) => {
+		const remainingText = `${options.remainingLines} more ${pluralize(options.remainingLines, "diff line")}`;
+		const hiddenHunksText =
+			options.hiddenHunks > 0
+				? `${options.hiddenHunks} more ${pluralize(options.hiddenHunks, "hunk")}`
+				: undefined;
+		const shortRemainingText = `${options.remainingLines} more ${pluralize(options.remainingLines, "line")}`;
+		const shortHiddenHunksText =
+			options.hiddenHunks > 0
+				? `${options.hiddenHunks} ${pluralize(options.hiddenHunks, "hunk")}`
+				: undefined;
+
+		const candidates = [
+			`… (${[remainingText, hiddenHunksText, showMoreHintText()].filter(Boolean).join(" • ")})`,
+			`… (${[remainingText, hiddenHunksText].filter(Boolean).join(" • ")})`,
+			`… (${[shortRemainingText, shortHiddenHunksText].filter(Boolean).join(" • ")})`,
+			options.hiddenHunks > 0
+				? `… (+${options.remainingLines} • +${options.hiddenHunks}h)`
+				: `… (+${options.remainingLines})`,
+			"…",
+		];
+
+		for (const candidate of candidates) {
+			if (ops.measure(candidate) <= safeWidth) {
+				return candidate;
+			}
+		}
+
+		return clampRenderedLineToWidth(candidates[candidates.length - 1] ?? "", safeWidth, ops);
+	});
+}

package/src/vendor/diff/shiki-highlight.ts

@@ -0,0 +1,92 @@
+export const MAX_HL_CHARS = 32_000;
+const MAX_CACHE_ENTRIES = 48;
+
+type CodeToAnsi = (code: string, lang: any, theme: any) => Promise<string>;
+type Loader = () => Promise<CodeToAnsi>;
+type Subscriber = { fallback: readonly string[]; invalidate: () => void };
+type Pending = { work: Promise<void>; subscribers: Set<Subscriber> };
+
+let defaultLoad: Promise<CodeToAnsi> | undefined;
+const loadDefault: Loader = () => {
+	if (!defaultLoad) {
+		// 变量形式的动态导入：tsc 不解析、运行时找不到时由上层 catch 降级为纯文本行。
+		const shikiCliModule = "@shikijs/cli" as string;
+		defaultLoad = import(shikiCliModule)
+			.then((module: { codeToANSI?: CodeToAnsi }) => module.codeToANSI as CodeToAnsi)
+			.catch((error) => {
+				defaultLoad = undefined;
+				throw error;
+			});
+	}
+	return defaultLoad;
+};
+
+function differs(lines: readonly string[], fallback: readonly string[]): boolean {
+	return lines.length !== fallback.length || lines.some((line, index) => line !== fallback[index]);
+}
+
+export class ShikiHighlightCache {
+	private readonly cache = new Map<string, string[]>();
+	private readonly pending = new Map<string, Pending>();
+	private readonly loader: Loader;
+
+	constructor(loader: Loader = loadDefault) {
+		this.loader = loader;
+	}
+
+	get(
+		code: string,
+		lang: string | undefined,
+		theme: string,
+		fallback: readonly string[],
+		invalidate?: () => void,
+	): string[] | undefined {
+		if (!lang || code.length > MAX_HL_CHARS) return undefined;
+		const key = `${theme}\0${lang}\0${code}`;
+		const cached = this.cache.get(key);
+		if (cached) {
+			this.cache.delete(key);
+			this.cache.set(key, cached);
+			return cached;
+		}
+
+		const existing = this.pending.get(key);
+		if (existing) {
+			if (invalidate && ![...existing.subscribers].some((item) => item.invalidate === invalidate)) {
+				existing.subscribers.add({ fallback, invalidate });
+			}
+			return undefined;
+		}
+
+		const pending: Pending = { work: undefined as never, subscribers: new Set() };
+		if (invalidate) pending.subscribers.add({ fallback, invalidate });
+		pending.work = this.loader()
+			.then((highlight) => highlight(code, lang, theme))
+			.then((ansi) => {
+				const lines = ansi.replace(/\r/g, "").replace(/\n$/, "").split("\n");
+				this.cache.set(key, lines);
+				while (this.cache.size > MAX_CACHE_ENTRIES) {
+					const oldest = this.cache.keys().next().value;
+					if (oldest !== undefined) this.cache.delete(oldest);
+				}
+				for (const subscriber of pending.subscribers) {
+					if (!differs(lines, subscriber.fallback)) continue;
+					try {
+						subscriber.invalidate();
+					} catch {
+						// One component must not prevent the other subscribers from repainting.
+					}
+				}
+			})
+			.catch(() => {})
+			.finally(() => this.pending.delete(key));
+		this.pending.set(key, pending);
+		return undefined;
+	}
+
+	clear(): void {
+		this.cache.clear();
+	}
+}
+
+export const shikiHighlightCache = new ShikiHighlightCache();

package/src/vendor/diff/write-execution.ts

@@ -0,0 +1,113 @@
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { lstat, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+
+export const MAX_COMPARABLE_WRITE_BYTES = 512_000;
+export const MAX_WRITE_METADATA_ENTRIES = 100;
+
+export type WriteExecutionMeta = {
+	fileExistedBeforeWrite: boolean;
+	previousContent?: string;
+	diffUnavailableReason?: string;
+};
+
+export class WriteExecutionMetadataStore {
+	readonly entries = new Map<string, WriteExecutionMeta>();
+
+	set(toolCallId: string, metadata: WriteExecutionMeta): void {
+		this.entries.delete(toolCallId);
+		this.entries.set(toolCallId, metadata);
+		while (this.entries.size > MAX_WRITE_METADATA_ENTRIES) {
+			const oldest = this.entries.keys().next().value;
+			if (oldest === undefined) break;
+			this.entries.delete(oldest);
+		}
+	}
+
+	get(toolCallId: unknown): WriteExecutionMeta | undefined {
+		return typeof toolCallId === "string" ? this.entries.get(toolCallId) : undefined;
+	}
+
+	delete(toolCallId: string): void {
+		this.entries.delete(toolCallId);
+	}
+
+	clear(): void {
+		this.entries.clear();
+	}
+}
+
+async function capturePreviousContent(absolutePath: string): Promise<WriteExecutionMeta> {
+	let info;
+	try {
+		info = await lstat(absolutePath);
+	} catch (error: any) {
+		if (error?.code === "ENOENT") return { fileExistedBeforeWrite: false };
+		return {
+			fileExistedBeforeWrite: true,
+			diffUnavailableReason: "unable to inspect the previous file",
+		};
+	}
+
+	if (!info.isFile()) {
+		return {
+			fileExistedBeforeWrite: true,
+			diffUnavailableReason: "previous path is not a regular file",
+		};
+	}
+	if (info.size > MAX_COMPARABLE_WRITE_BYTES) {
+		return {
+			fileExistedBeforeWrite: true,
+			diffUnavailableReason: `previous file exceeds ${MAX_COMPARABLE_WRITE_BYTES} bytes`,
+		};
+	}
+
+	try {
+		const bytes = await readFile(absolutePath);
+		const previousContent = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+		return { fileExistedBeforeWrite: true, previousContent };
+	} catch {
+		return {
+			fileExistedBeforeWrite: true,
+			diffUnavailableReason: "previous file is not comparable UTF-8 text",
+		};
+	}
+}
+
+export async function executeWriteWithMetadata(
+	store: WriteExecutionMetadataStore,
+	toolCallId: string,
+	params: { path: string; content: string },
+	signal: AbortSignal | undefined,
+	cwd: string,
+): Promise<{ content: Array<{ type: "text"; text: string }>; details: undefined }> {
+	const absolutePath = isAbsolute(params.path) ? params.path : resolve(cwd, params.path);
+	store.delete(toolCallId);
+	try {
+		return await withFileMutationQueue(absolutePath, async () => {
+			const throwIfAborted = () => {
+				if (signal?.aborted) throw new Error("Operation aborted");
+			};
+			throwIfAborted();
+			const metadata = await capturePreviousContent(absolutePath);
+			throwIfAborted();
+			await mkdir(dirname(absolutePath), { recursive: true });
+			throwIfAborted();
+			await writeFile(absolutePath, params.content, "utf8");
+			throwIfAborted();
+			store.set(toolCallId, metadata);
+			return {
+				content: [
+					{
+						type: "text",
+						text: `Successfully wrote ${params.content.length} bytes to ${params.path}`,
+					},
+				],
+				details: undefined,
+			};
+		});
+	} catch (error) {
+		store.delete(toolCallId);
+		throw error;
+	}
+}

package/src/vendor/diff-config.ts

@@ -0,0 +1,30 @@
+/**
+ * vendored diff 模块的显示配置段。
+ * 类型与默认值取自 pi-cc-extensions extensions/config/config.ts 的 ToolDisplay 段（MIT），
+ * 值由 lean-tidy.json 的 "diff" 对象桥接（见 index.ts 的 loadConfig）。
+ */
+export type DiffViewMode = "auto" | "split" | "unified";
+export type DiffIndicatorMode = "bars" | "classic" | "none";
+
+export type ToolDisplayConfig = {
+	diffViewMode: DiffViewMode;
+	diffIndicatorMode: DiffIndicatorMode;
+	diffSplitMinWidth: number;
+	editDiffCollapsedLines: number;
+	writeDiffCollapsedLines: number;
+	diffWordWrap: boolean;
+	expandedPreviewMaxLines: number;
+};
+
+export const DEFAULT_TOOL_DISPLAY_CONFIG: ToolDisplayConfig = {
+	diffViewMode: "auto",
+	diffIndicatorMode: "bars",
+	diffSplitMinWidth: 120,
+	editDiffCollapsedLines: 24,
+	writeDiffCollapsedLines: 0,
+	diffWordWrap: true,
+	expandedPreviewMaxLines: 40,
+};
+
+/** 原 patch-keys.ts 中 rich diff 使用的组件标记 symbol。 */
+export const RICH_DIFF_COMPONENT = Symbol.for("lean-tidy.rich-diff-component");

package/src/vendor/show-more-hint.ts

@@ -0,0 +1,38 @@
+/**
+ * show-more 提示文本：fullscreen 下鼠标 hover/click 可用，提示 "click to show more"；
+ * 其他模式（regular 保留终端原生 scrollback、不启用鼠标上报）提示默认展开快捷键。
+ *
+ * tui 模式由 mouse-interaction 在 renderer 回调中维护；未安装时按 fullscreen 处理，
+ * 保证纯渲染测试与既有行为不变。
+ */
+import { getKeybindings } from "@earendil-works/pi-tui";
+
+let toolTuiFullscreen: boolean | undefined;
+
+export function setToolTuiFullscreen(value: boolean): void {
+	toolTuiFullscreen = value;
+}
+
+export function isToolTuiFullscreen(): boolean {
+	return toolTuiFullscreen !== false;
+}
+
+function formatKeyPart(part: string): string {
+	// 与 pi 内置 keybinding-hints 一致：macOS 上 alt 显示为 option
+	return process.platform === "darwin" && part.toLowerCase() === "alt" ? "option" : part;
+}
+
+/** 默认展开快捷键（app.tools.expand）显示文本；未配置时回退 ctrl+o。 */
+export function expandShortcutText(): string {
+	const keys = getKeybindings().getKeys("app.tools.expand");
+	if (keys.length === 0) return "ctrl+o";
+	return keys
+		.join("/")
+		.split("/")
+		.map((part) => part.split("+").map(formatKeyPart).join("+"))
+		.join("/");
+}
+
+export function showMoreHintText(): string {
+	return isToolTuiFullscreen() ? "click to show more" : `${expandShortcutText()} to show more`;
+}

package/src/vendor/tool-result-sanitize.ts

@@ -0,0 +1,24 @@
+const UNSAFE_TERMINAL_ESCAPE = new RegExp(
+	"(?:\\u001B\\]|\\u009D)[\\s\\S]*?(?:\\u0007|\\u001B\\x5C|\\u009C)" +
+		"|(?:\\u001B[PX^_]|\\u0090)[\\s\\S]*?(?:\\u001B\\x5C|\\u009C)" +
+		"|(?:\\u001B\\[|\\u009B)[0-?]*[ -/]*[@-~]" +
+		"|\\u001B[@-_]",
+	"g",
+);
+
+/**
+ * Prevent captured terminal control responses from being replayed by tool renderers.
+ * Optional `maxChars` trims the input first so preview/one-line paths never scan multi-MB outputs.
+ */
+export function sanitizeToolResultText(value: string, maxChars?: number): string {
+	const source =
+		typeof maxChars === "number" && maxChars >= 0 && value.length > maxChars
+			? value.slice(0, maxChars)
+			: value;
+	return source
+		.replace(UNSAFE_TERMINAL_ESCAPE, "")
+		.replace(/\x1B/g, "")
+		.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, "")
+		.replace(/\r\n/g, "\n")
+		.replace(/\r/g, "\n");
+}

package/src/working-message.ts

@@ -0,0 +1,140 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+// Vendored from minuque/pi-cc-extensions (MIT); see vendor/diff/ATTRIBUTION.md for diff's separate provenance.
+// This file only owns Pi's Working... row, not the user's custom footer.
+function formatDuration(ms: number): string {
+	const seconds = Math.floor(ms / 1_000);
+	if (seconds < 1) return "";
+	const hours = Math.floor(seconds / 3_600);
+	const minutes = Math.floor((seconds % 3_600) / 60);
+	const rest = seconds % 60;
+	return hours ? `${hours}h ${minutes}m ${rest}s` : minutes ? `${minutes}m ${rest}s` : `${rest}s`;
+}
+
+const REFRESH_INTERVAL_MS = 1_000;
+/** Elapsed time is only shown once the turn has run this long. */
+const SHOW_TIMER_AFTER_MS = 3_000;
+
+type WorkingUi = {
+	setWorkingMessage(message?: string): void;
+};
+
+/**
+ * Extend Pi's footer working row while preserving its spinner and "Working...":
+ * `⠋ Working... (12s)`
+ *
+ * Timer spans the whole agent loop (一南 2026-09-26): a user message triggers
+ * several assistant runs (thinking → tool → … → final prose); elapsed time
+ * counts from the first run and only resets on agent_settled — not on every
+ * turn_start, which used to restart the clock from zero mid-turn.
+ *
+ * Token counting was removed on 一南's request (2026-11-27): only time is shown.
+ */
+export default function (pi: ExtensionAPI): void {
+	let turnActive = false;
+	let agentStartTime = 0;
+	let turnStartTime = 0;
+	let refreshTimer: ReturnType<typeof setTimeout> | null = null;
+	let lastMessage: string | null = null;
+	let activeCtx: { ui: WorkingUi | undefined; hasUI: boolean } | null = null;
+
+	function buildWorkingMessage(): string {
+		const elapsed = Date.now() - (agentStartTime || turnStartTime);
+		if (elapsed < SHOW_TIMER_AFTER_MS) return "";
+		// formatDuration 低于 1 秒返回 ""，此处回退 "0s" 保持计时器连续跳动。
+		return `Working... (${formatDuration(elapsed) || "0s"})`;
+	}
+
+	function restoreDefaultWorkingMessage(): void {
+		lastMessage = null;
+		if (!activeCtx?.hasUI) return;
+		try {
+			activeCtx.ui?.setWorkingMessage();
+		} catch {
+			// Noop when the TUI is unavailable.
+		}
+	}
+
+	function syncWorkingMessage(force = false): void {
+		if (!activeCtx?.hasUI) return;
+		const next = buildWorkingMessage();
+		if (!next) {
+			if (force) restoreDefaultWorkingMessage();
+			return;
+		}
+		if (!force && next === lastMessage) return;
+		lastMessage = next;
+		try {
+			activeCtx.ui?.setWorkingMessage(next);
+		} catch {
+			// Noop when the TUI is unavailable.
+		}
+	}
+
+	function scheduleRefreshTick(): void {
+		if (!turnActive || refreshTimer) return;
+		refreshTimer = setTimeout(() => {
+			refreshTimer = null;
+			try {
+				syncWorkingMessage();
+			} finally {
+				scheduleRefreshTick();
+			}
+		}, REFRESH_INTERVAL_MS);
+		refreshTimer.unref?.();
+	}
+
+	function stopRefreshLoop(): void {
+		if (!refreshTimer) return;
+		clearTimeout(refreshTimer);
+		refreshTimer = null;
+	}
+
+	function clearDisplay(): void {
+		stopRefreshLoop();
+		agentStartTime = 0;
+		turnStartTime = 0;
+		restoreDefaultWorkingMessage();
+	}
+
+	pi.on("before_agent_start", async () => {
+		if (!agentStartTime) agentStartTime = Date.now();
+	});
+
+	pi.on("turn_start", async (_event, ctx) => {
+		// Deliberately no clock reset here: one user message spans many turns;
+		// only agent_settled ends the streak.
+		turnActive = true;
+		activeCtx = ctx;
+		turnStartTime = Date.now();
+		if (!agentStartTime) agentStartTime = turnStartTime;
+		syncWorkingMessage(true);
+		scheduleRefreshTick();
+	});
+
+	pi.on("turn_end", async (_event, ctx) => {
+		turnActive = false;
+		activeCtx = ctx;
+		stopRefreshLoop();
+		// No clock reset: the next turn of the same user message keeps counting.
+		// No completion message: return immediately to Pi's default idle state.
+		restoreDefaultWorkingMessage();
+	});
+
+	pi.on("agent_settled", async () => {
+		turnActive = false;
+		clearDisplay();
+	});
+
+	pi.on("agent_end", async () => {
+		// A retry or queued continuation can follow agent_end. Only the final
+		// agent_settled boundary resets the cross-turn clock.
+		turnActive = false;
+		stopRefreshLoop();
+	});
+
+	pi.on("session_shutdown", async () => {
+		turnActive = false;
+		clearDisplay();
+		activeCtx = null;
+	});
+}