pi-my-compact-ui 0.2.2 → 0.3.0

package/src/settings.ts

@@ -0,0 +1,142 @@
+/** 配置交互界面与数值编辑器。 */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import { Key, SettingsList, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import type { Component, SettingItem } from "@earendil-works/pi-tui";
+import { config, saveConfig } from "./config.js";
+import { runtime } from "./state.js";
+
+export const CONFIG_KEYS = [
+	{
+		id: "expandedToolLines",
+		label: "Expanded tool lines",
+		description: "Result lines shown per tool when expanded",
+		min: 1,
+		max: 50,
+		step: 1,
+	},
+	{
+		id: "expandedThinkingLines",
+		label: "Expanded thinking lines",
+		description: "Thinking lines shown when expanded",
+		min: 1,
+		max: 100,
+		step: 1,
+	},
+	{
+		id: "maxGroupEntries",
+		label: "Max collapsed entries",
+		description: "Maximum entries shown in collapsed group",
+		min: 1,
+		max: 30,
+		step: 1,
+	},
+] as const;
+
+export function makeStepper(
+	title: string,
+	initial: number,
+	meta: { min: number; max: number; step: number },
+	theme: any,
+	done: (value?: string) => void,
+): Component {
+	let value = initial;
+	let cachedWidth: number | undefined;
+	let cachedLines: string[] | undefined;
+	const fg = (color: string, t: string) => theme?.fg?.(color, t) ?? t;
+
+	return {
+		render(width: number): string[] {
+			if (cachedLines && cachedWidth === width) return cachedLines;
+			const barLen = Math.max(1, Math.min(width - 10, 40));
+			const ratio = (value - meta.min) / Math.max(1, meta.max - meta.min);
+			const filled = Math.round(ratio * barLen);
+			const bar = "█".repeat(filled) + "░".repeat(Math.max(0, barLen - filled));
+			const titleText = theme?.bold ? theme.bold(title) : title;
+			cachedLines = [
+				fg("accent", titleText),
+				"",
+				`  ${fg("accent", String(value))}`,
+				`  ${fg("muted", bar)}`,
+				"",
+				fg("dim", "  ◀ ▶ / − +  adjust    Enter  save    Esc  cancel"),
+			].map((line) => truncateToWidth(line, Math.max(1, width)));
+			cachedWidth = width;
+			return cachedLines;
+		},
+		handleInput(data: string): void {
+			if (matchesKey(data, Key.left) || matchesKey(data, Key.down) || data === "-" || data === "_") {
+				value = Math.max(meta.min, value - meta.step);
+			} else if (matchesKey(data, Key.right) || matchesKey(data, Key.up) || data === "+" || data === "=") {
+				value = Math.min(meta.max, value + meta.step);
+			} else if (matchesKey(data, Key.enter) || matchesKey(data, Key.space)) {
+				done(String(value));
+				return;
+			} else if (matchesKey(data, Key.escape)) {
+				done(undefined);
+				return;
+			}
+			cachedWidth = undefined;
+		},
+		invalidate(): void {
+			cachedWidth = undefined;
+		},
+	};
+}
+
+export function registerConfigCommand(pi: ExtensionAPI): void {
+	pi.registerCommand("compact-ui-config", {
+		description: "Interactive compact-ui settings (arrows to select, Enter to adjust, Esc to close)",
+		handler: async (_args, ctx) => {
+			// Non-TUI modes (print/json) can't show the interactive menu.
+			if (!ctx.hasUI) {
+				ctx.ui.notify(
+					`compact: expandedToolLines=${config.expandedToolLines}, expandedThinkingLines=${config.expandedThinkingLines}`,
+					"info",
+				);
+				return;
+			}
+
+			const changed = await ctx.ui.custom<boolean>((tui, theme, _keybindings, done) => {
+				let anyChanged = false;
+				const items: SettingItem[] = CONFIG_KEYS.map((meta) => ({
+					id: meta.id,
+					label: meta.label,
+					currentValue: String((config as any)[meta.id]),
+					description: meta.description,
+					submenu: (currentValue: string, subDone: (value?: string) => void) =>
+						makeStepper(meta.label, Number(currentValue), meta, theme, subDone),
+				}));
+				const settingsList = new SettingsList(
+					items,
+					Math.min(items.length, 15),
+					getSettingsListTheme(),
+					(id, newValue) => {
+						// Persist and refresh the live groups when SettingsList commits a change.
+						(config as any)[id] = Number(newValue);
+						saveConfig();
+						anyChanged = true;
+						for (const g of runtime.groups) g.invalidate();
+					},
+					() => done(anyChanged),
+				);
+				return {
+					render(width: number) {
+						return settingsList.render(width);
+					},
+					invalidate() {
+						settingsList.invalidate();
+					},
+					handleInput(data: string) {
+						settingsList.handleInput?.(data);
+						tui.requestRender();
+					},
+				};
+			});
+
+			if (changed) {
+				ctx.ui.notify("compact-ui settings saved", "info");
+			}
+		},
+	});
+}

package/src/state.ts

@@ -0,0 +1,80 @@
+/** 集中管理会话状态；集合与锚点通过工厂创建，便于测试隔离。 */
+import type { ThinkingEntry, PreparingTool, AssistantContentState } from "./types.js";
+import type { ToolGroupComponent } from "./tool-group.js";
+import type { OverlayHandle, Container } from "@earendil-works/pi-tui";
+import type { DetailModalComponent, InspectSelectorModal } from "./modals.js";
+
+/** Mutable session/UI state. A fresh snapshot also makes isolated tests possible. */
+export interface RuntimeState {
+	currentTheme: any;
+	activeThinking: ThinkingEntry | null;
+	activeThinkingIndex: number | null;
+	activeThinkingBlocks: Map<number, string>;
+	unattachedThinking: ThinkingEntry[];
+	thinkingEntrySeq: number;
+	handledTextIndexes: Set<number>;
+	sealedThinkingIndexes: Set<number>;
+	pendingTextSeal: boolean;
+	pendingTextOrdinal: number | null;
+	lastActiveGroup: ToolGroupComponent | null;
+	lastSealedThinkingEntry: ThinkingEntry | null;
+	lastReportedReasoningTokens: number;
+	lastStreamingComp: any;
+	lastChatContainer: any;
+	toolStarts: Map<string, number>;
+	toolDurations: Map<string, number>;
+	turnStartMs: number;
+	preparingByIndex: Map<number, PreparingTool>;
+	activeModalHandle: OverlayHandle | null;
+	activeModalComponent: DetailModalComponent | null;
+	activeModalCloseFn: (() => void) | null;
+	activeUIContext: any;
+	activeSelectorHandle: OverlayHandle | null;
+	activeSelectorComponent: InspectSelectorModal | null;
+	activeSelectorCloseFn: (() => void) | null;
+	animTimer: ReturnType<typeof setTimeout> | null;
+	capturedTui: any;
+	groups: Set<ToolGroupComponent>;
+	assistantContentContainers: WeakSet<Container>;
+	assistantContentStates: WeakMap<Container, AssistantContentState>;
+	groupAnchors: WeakMap<ToolGroupComponent, { container: Container; ordinal: number; }>;
+}
+
+export function createRuntimeState(): RuntimeState {
+	return {
+		currentTheme: null,
+		activeThinking: null,
+		activeThinkingIndex: null,
+		activeThinkingBlocks: new Map<number, string>(),
+		unattachedThinking: [],
+		thinkingEntrySeq: 0,
+		handledTextIndexes: new Set<number>(),
+		sealedThinkingIndexes: new Set<number>(),
+		pendingTextSeal: false,
+		pendingTextOrdinal: null,
+		lastActiveGroup: null,
+		lastSealedThinkingEntry: null,
+		lastReportedReasoningTokens: 0,
+		lastStreamingComp: null,
+		lastChatContainer: null,
+		toolStarts: new Map<string, number>(),
+		toolDurations: new Map<string, number>(),
+		turnStartMs: 0,
+		preparingByIndex: new Map<number, PreparingTool>(),
+		activeModalHandle: null,
+		activeModalComponent: null,
+		activeModalCloseFn: null,
+		activeUIContext: null,
+		activeSelectorHandle: null,
+		activeSelectorComponent: null,
+		activeSelectorCloseFn: null,
+		animTimer: null,
+		capturedTui: null,
+		groups: new Set<ToolGroupComponent>(),
+		assistantContentContainers: new WeakSet<Container>(),
+		assistantContentStates: new WeakMap<Container, AssistantContentState>(),
+		groupAnchors: new WeakMap<ToolGroupComponent, { container: Container; ordinal: number }>(),
+	};
+}
+
+export const runtime = createRuntimeState();

package/src/streaming-tools.ts

@@ -0,0 +1,232 @@
+/** 在参数流式输出阶段创建工具占位行，并迁移到真实工具组件。 */
+import { runtime } from "./state.js";
+import { PARENT_KEY } from "./constants.js";
+import { isToolGroup } from "./guards.js";
+import { ToolGroupComponent } from "./tool-group.js";
+import { detachGroup, noteGroupMount } from "./assistant-patches.js";
+import type { PreparingTool } from "./types.js";
+import { locateStreamingToolCall, streamingToolArgs } from "./helpers.js";
+
+export function toolElapsed(tool: any): string {
+	if (typeof tool?._elapsedDuration === "number") {
+		return tool._elapsedDuration.toFixed(1);
+	}
+	const knownDuration = runtime.toolDurations.get(tool.toolCallId);
+	if (knownDuration !== undefined) {
+		tool._elapsedDuration = knownDuration;
+		return knownDuration.toFixed(1);
+	}
+	if (tool?._groupEndAt !== undefined) {
+		const start = runtime.toolStarts.get(tool.toolCallId) ?? tool._groupEndAt;
+		const dur = Math.max(0, (tool._groupEndAt - start) / 1000);
+		tool._elapsedDuration = dur;
+		return dur.toFixed(1);
+	}
+	if (tool?.result) {
+		const resultTs = Number(tool.result?.timestamp);
+		const start = runtime.toolStarts.get(tool.toolCallId);
+		if (start && resultTs && resultTs >= start) {
+			const dur = (resultTs - start) / 1000;
+			tool._elapsedDuration = dur;
+			return dur.toFixed(1);
+		}
+		tool._elapsedDuration = 0;
+		return "0.0";
+	}
+	const start = runtime.toolStarts.get(tool.toolCallId);
+	if (start !== undefined) {
+		return Math.max(0, (Date.now() - start) / 1000).toFixed(1);
+	}
+	return "0.0";
+}
+
+export function rememberToolStart(toolCallId: string): void {
+	if (!toolCallId || runtime.toolStarts.has(toolCallId) || runtime.toolDurations.has(toolCallId)) return;
+	runtime.toolStarts.set(toolCallId, Date.now());
+}
+
+export function loadSessionToolTimings(entries: readonly any[]): void {
+	if (!Array.isArray(entries)) return;
+	for (const entry of entries) {
+		if (entry?.type === "message" && entry.message) {
+			const msg = entry.message;
+			if (msg.role === "assistant" && Array.isArray(msg.content)) {
+				const startTime = Number(msg.timestamp) || (entry.timestamp ? new Date(entry.timestamp).getTime() : 0);
+				for (const block of msg.content) {
+					if (block.type === "toolCall" && block.id) {
+						if (startTime > 0) runtime.toolStarts.set(block.id, startTime);
+					}
+				}
+			} else if (msg.role === "toolResult" && msg.toolCallId) {
+				const endTime = Number(msg.timestamp) || (entry.timestamp ? new Date(entry.timestamp).getTime() : 0);
+				const startTime = runtime.toolStarts.get(msg.toolCallId);
+				if (startTime && endTime >= startTime) {
+					runtime.toolDurations.set(msg.toolCallId, (endTime - startTime) / 1000);
+				}
+			}
+		}
+	}
+}
+
+export function findGroupedTool(toolCallId: string, contentIndex: number): any | undefined {
+	for (const group of runtime.groups) {
+		for (const entry of group.entries) {
+			if (entry.kind !== "tool") continue;
+			const tool = entry.tool;
+			if (toolCallId && tool?.toolCallId === toolCallId) return tool;
+			if (tool?._contentIndex === contentIndex) return tool;
+		}
+	}
+	return undefined;
+}
+
+export function invalidateGroupedTool(tool: any): void {
+	const group = tool?.owner ?? tool?.[PARENT_KEY];
+	if (isToolGroup(group)) {
+		if (!group.sealed) runtime.lastActiveGroup = group;
+		group.invalidate();
+	} else {
+		runtime.lastActiveGroup?.invalidate();
+	}
+	runtime.capturedTui?.requestRender?.();
+}
+
+export function findOpenGroup(): ToolGroupComponent | null {
+	if (runtime.lastActiveGroup && !runtime.lastActiveGroup.sealed && runtime.groups.has(runtime.lastActiveGroup)) return runtime.lastActiveGroup;
+	for (const group of runtime.groups) {
+		if (!group.sealed) return group;
+	}
+	return null;
+}
+
+export function placeGroupAfter(parent: any, after: any, group: ToolGroupComponent): void {
+	const children = parent?.children;
+	if (!Array.isArray(children)) return;
+	detachGroup(group, parent);
+	const existing = children.indexOf(group);
+	if (existing >= 0) children.splice(existing, 1);
+	const afterIndex = after ? children.indexOf(after) : -1;
+	children.splice(afterIndex >= 0 ? afterIndex + 1 : children.length, 0, group);
+	noteGroupMount(parent, group);
+	runtime.lastActiveGroup = group;
+}
+
+export function openToolGroup(): ToolGroupComponent | null {
+	const open = findOpenGroup();
+	if (open) {
+		if (runtime.lastChatContainer && runtime.lastStreamingComp) placeGroupAfter(runtime.lastChatContainer, runtime.lastStreamingComp, open);
+		return open;
+	}
+	if (!runtime.lastChatContainer || !runtime.lastStreamingComp) return null;
+	let group: ToolGroupComponent;
+	const parent = runtime.lastChatContainer;
+	const children = parent.children;
+	if (!Array.isArray(children)) return null;
+	const idx = children.indexOf(runtime.lastStreamingComp);
+	group = new ToolGroupComponent();
+	detachGroup(group);
+	children.splice(idx >= 0 ? idx + 1 : children.length, 0, group);
+	noteGroupMount(parent, group);
+	runtime.groups.add(group);
+	runtime.lastActiveGroup = group;
+	parent.invalidate?.();
+	return group;
+}
+
+export function attachPreparingTool(tool: PreparingTool): void {
+	if (tool.owner) return;
+	const group = openToolGroup();
+	if (!group) return;
+	tool.owner = group;
+	group.entries.push({ kind: "tool", tool });
+	group.invalidate();
+	runtime.lastActiveGroup = group;
+}
+
+export function detachPreparingTool(tool: PreparingTool): void {
+	const group = tool.owner;
+	if (group) {
+		const index = group.entries.findIndex((entry) => entry.kind === "tool" && entry.tool === tool);
+		if (index >= 0) group.entries.splice(index, 1);
+	}
+	tool.owner = null;
+}
+
+export function takePreparingTool(real: any): PreparingTool | undefined {
+	const id = String(real?.toolCallId ?? "");
+	const name = String(real?.toolName ?? "");
+	if (id) {
+		for (const [index, candidate] of runtime.preparingByIndex) {
+			if (candidate.toolCallId === id) {
+				runtime.preparingByIndex.delete(index);
+				return candidate;
+			}
+		}
+	}
+	const matches = [...runtime.preparingByIndex.entries()].filter(([, candidate]) => candidate.toolName === name);
+	if (matches.length === 1) {
+		runtime.preparingByIndex.delete(matches[0][0]);
+		return matches[0][1];
+	}
+	return undefined;
+}
+
+export function absorbPreparingTool(real: any): void {
+	const preparing = takePreparingTool(real);
+	if (!preparing) return;
+	const id = String(real?.toolCallId ?? "");
+	const start = runtime.toolStarts.get(preparing.toolCallId);
+	if (start !== undefined && id && !runtime.toolStarts.has(id)) runtime.toolStarts.set(id, start);
+	real._contentIndex = preparing._contentIndex;
+	if ((!real.args || Object.keys(real.args).length === 0) && preparing.args) real.args = preparing.args;
+	detachPreparingTool(preparing);
+}
+
+export function clearPreparingTools(): void {
+	for (const tool of runtime.preparingByIndex.values()) detachPreparingTool(tool);
+	runtime.preparingByIndex.clear();
+}
+
+export function noteStreamingToolCall(content: any[], streamEvent: any): void {
+	const located = locateStreamingToolCall(content, streamEvent);
+	if (!located) return;
+	const { index, block } = located;
+	const id = String(block.id || "");
+	const name = String(block.name || "tool");
+	const args = streamingToolArgs(block);
+	const existing = findGroupedTool(id, index);
+	if (existing && !existing._preparing) {
+		existing._contentIndex = index;
+		existing.args = args;
+		rememberToolStart(String(existing.toolCallId || id));
+		invalidateGroupedTool(existing);
+		return;
+	}
+
+	let preparing = runtime.preparingByIndex.get(index);
+	if (!preparing) {
+		preparing = {
+			toolName: name,
+			toolCallId: id || `preparing:${index}`,
+			args,
+			isPartial: true,
+			_preparing: true,
+			_contentIndex: index,
+			owner: null,
+		};
+		runtime.preparingByIndex.set(index, preparing);
+		attachPreparingTool(preparing);
+	} else {
+		if (name && name !== "tool") preparing.toolName = name;
+		if (id && preparing.toolCallId !== id) {
+			const previous = preparing.toolCallId;
+			preparing.toolCallId = id;
+			const start = runtime.toolStarts.get(previous);
+			if (start !== undefined && !runtime.toolStarts.has(id)) runtime.toolStarts.set(id, start);
+		}
+		preparing.args = args;
+		if (!preparing.owner) attachPreparingTool(preparing);
+	}
+	rememberToolStart(preparing.toolCallId);
+	invalidateGroupedTool(preparing);
+}

package/src/thinking.ts

@@ -0,0 +1,62 @@
+/** 思考段生命周期与估算/精确 token 用量更新。 */
+import { runtime } from "./state.js";
+import { estimateTextTokens } from "./helpers.js";
+import type { ThinkingEntry } from "./types.js";
+
+export function updateActiveThinkingTokens(message: any): void {
+	const entry = runtime.activeThinking;
+	if (!entry) return;
+	entry.text = [...runtime.activeThinkingBlocks.values()].filter((text) => text.trim()).join("\n\n");
+	// Most providers report reasoning usage only when the response finishes. While
+	// streaming, fall back to pi's own chars/4 token heuristic and mark it with ≈.
+	const reported = Number(message?.usage?.reasoning);
+	if (Number.isFinite(reported) && reported > 0) {
+		entry.tokens = reported;
+		entry.tokensExact = true;
+		runtime.lastReportedReasoningTokens = reported;
+		return;
+	}
+	entry.tokens = estimateTextTokens(entry.text);
+	entry.tokensExact = false;
+}
+
+export function createThinkingEntry(): ThinkingEntry {
+	const entry: ThinkingEntry = {
+		kind: "thinking",
+		id: runtime.thinkingEntrySeq++,
+		text: "",
+		tokens: 0,
+		tokensExact: false,
+		active: true,
+		owner: null,
+	};
+	runtime.activeThinking = entry;
+	runtime.activeThinkingBlocks.clear();
+	runtime.unattachedThinking.push(entry);
+	return entry;
+}
+
+export function finalizeActiveThinking(): void {
+	const entry = runtime.activeThinking;
+	if (!entry) return;
+	entry.active = false;
+	entry.owner?.invalidate();
+	if (runtime.activeThinkingIndex !== null) runtime.sealedThinkingIndexes.add(runtime.activeThinkingIndex);
+	runtime.lastSealedThinkingEntry = entry;
+	runtime.activeThinking = null;
+	runtime.activeThinkingIndex = null;
+	runtime.activeThinkingBlocks.clear();
+}
+
+export function refreshSealedThinkingTokens(reportedReasoning?: unknown): void {
+	const reported = Number(reportedReasoning);
+	if (Number.isFinite(reported) && reported > 0) runtime.lastReportedReasoningTokens = reported;
+	const entry = runtime.lastSealedThinkingEntry;
+	if (!entry || entry.tokensExact) return;
+	if (!entry.text.trim()) return; // no thinking row to correct
+	if (!(runtime.lastReportedReasoningTokens > 0)) return;
+	entry.tokens = runtime.lastReportedReasoningTokens;
+	entry.tokensExact = true;
+	entry.owner?.invalidate();
+	runtime.capturedTui?.requestRender?.();
+}