pi-open-tui 0.3.13 → 0.4.0

package/extensions/open-tui/index.ts

@@ -8,6 +8,7 @@ import { readRuntimeInfo } from "./runtime.ts";
 import { SessionLifecycle } from "./session-lifecycle.ts";
 import { registerSettingsCommand } from "./settings-command.ts";
 import { formatTurnTelemetry, TurnTelemetryTracker } from "./telemetry.ts";
+import { registerToolView } from "./tool-view.ts";
 import {
 	createInitialState,
 	getModelMeta,
@@ -24,9 +25,6 @@ import {
 } from "./peek.ts";
 
 type PendingUiChange = "install" | "uninstall";
-const HIDDEN_THINKING_HORIZONTAL_PADDING = 2;
-// Pi's fullscreen transcript can reserve one more column for its scrollbar.
-const HIDDEN_THINKING_SCROLLBAR_RESERVE = 1;
 
 export function getPendingUiChange(enabled: boolean, active: boolean): PendingUiChange | undefined {
 	if (enabled === active) return undefined;
@@ -48,6 +46,7 @@ export default function (pi: ExtensionAPI) {
 	const turnTelemetry = new TurnTelemetryTracker();
 
 	let config: OpenTuiConfig = structuredClone(DEFAULT_CONFIG);
+	let configLoaded = false;
 	let active = false;
 	let lastCtx: ExtensionContext | undefined;
 	let requestFooterRender: (() => void) | undefined;
@@ -78,29 +77,16 @@ export default function (pi: ExtensionAPI) {
 	/** Pi decides whether this label is visible; our toggle only controls updates. */
 	const isPeekEnabled = () => sessionLifecycle.isCurrent() && config.enabled && config.thinkingPeek.lines > 0 && active;
 
-	/** Keep each native hidden-thinking label row within Pi's narrowest transcript width. */
-	const hiddenThinkingLabelWidth = (): number => {
-		if (!editor) throw new Error("Open TUI editor is not installed");
-		return Math.max(
-			1,
-			editor.getViewportWidth() - HIDDEN_THINKING_HORIZONTAL_PADDING - HIDDEN_THINKING_SCROLLBAR_RESERVE,
-		);
-	};
-
 	const setPeekLabel = (ctx?: ExtensionContext): void => {
 		if (!isPeekEnabled() || peek.phase === "idle") return;
 		const target = ctx ?? lastCtx;
 		if (!target || !isTuiContext(target)) return;
 		if (!editor) throw new Error("Open TUI editor is not installed");
-		editor.setLatestHiddenThinkingLabel(
-			buildPeekLabel(
-				peek,
-				peekFrame,
-				resolveGlyphs(config.icons.mode),
-				hiddenThinkingLabelWidth(),
-				config.thinkingPeek.lines,
-			),
-		);
+		const snapshot = { ...peek };
+		const frame = peekFrame;
+		const glyphs = resolveGlyphs(config.icons.mode);
+		const lines = config.thinkingPeek.lines;
+		editor.setLatestHiddenThinkingLabel((width) => buildPeekLabel(snapshot, frame, glyphs, width, lines));
 		peekLabelActive = true;
 	};
 
@@ -130,7 +116,8 @@ export default function (pi: ExtensionAPI) {
 			return;
 		}
 		if (!active) {
-			cleanupHeader = installHeader(pi, ctx);
+			// Leave the header slot alone when disabled so another extension's header survives.
+			if (config.header) cleanupHeader = installHeader(pi, ctx);
 			const footer = installFooter(
 				ctx,
 				() => state,
@@ -244,6 +231,7 @@ export default function (pi: ExtensionAPI) {
 
 		ensureConfigExists();
 		config = loadConfig((msg, level) => ctx.ui.notify(msg, level));
+		configLoaded = true;
 		clearPeekLabel(ctx);
 
 		applyUi(ctx);
@@ -382,10 +370,26 @@ export default function (pi: ExtensionAPI) {
 		refreshInteractiveState(ctx);
 	});
 
+	if (typeof pi.registerToolRenderer === "function") {
+		registerToolView(
+			pi,
+			() => {
+				// Resumed sessions rebuild their rows before session_start fires, so read the file once here.
+				if (!configLoaded) {
+					config = loadConfig();
+					configLoaded = true;
+				}
+				return config.enabled ? config.toolView.mode : "native";
+			},
+			() => resolveGlyphs(config.icons.mode),
+		);
+	}
+
 	registerSettingsCommand(pi, {
 		getConfig: () => config,
 		onConfigChanged: (newConfig) => {
 			const cursorStyleChanged = config.cursorStyle !== newConfig.cursorStyle;
+			const headerChanged = config.header !== newConfig.header;
 			const thinkingPeekLinesChanged = config.thinkingPeek.lines !== newConfig.thinkingPeek.lines;
 			saveConfig(newConfig);
 			config = newConfig;
@@ -398,6 +402,10 @@ export default function (pi: ExtensionAPI) {
 			if (cursorStyleChanged && active && editor) {
 				editor.setCursorStyle(newConfig.cursorStyle);
 			}
+			if (headerChanged && active && lastCtx) {
+				cleanupHeader?.();
+				cleanupHeader = newConfig.header ? installHeader(pi, lastCtx) : undefined;
+			}
 			if (lastCtx) {
 				pendingUiChange = getPendingUiChange(newConfig.enabled, active);
 			}

package/extensions/open-tui/settings-command.ts

@@ -28,8 +28,10 @@ const COPY = {
 		hint: "Tab/Shift+Tab/←/→: tabs · ↑/↓: move · Enter/Space: change · Esc/q: close",
 		labels: {
 			enabled: "Enabled",
+			header: "Override header",
 			inlineFooter: "Footer in editor border",
 			thinkingPeek: "Thinking peek",
+			toolView: "Tool view",
 			language: "Language",
 			cursorStyle: "Cursor style",
 			iconMode: "Icon mode",
@@ -56,6 +58,7 @@ const COPY = {
 			on: "On",
 			off: "Off",
 			thinkingPeek: { off: "Off", one: "1 line", two: "2 lines" },
+			toolView: { native: "Native", compact: "Compact" },
 			languages: { en: "English", zh: "简体中文" },
 			cursorStyles: { block: "Block", bar: "Bar", underline: "Underline" },
 			icons: { auto: "Auto", nerd: "Nerd", unicode: "Unicode", ascii: "ASCII" },
@@ -67,8 +70,10 @@ const COPY = {
 		hint: "Tab/Shift+Tab/←/→：切页 · ↑/↓：移动 · Enter/Space：更改 · Esc/q：关闭",
 		labels: {
 			enabled: "启用",
+			header: "覆盖顶部信息栏",
 			inlineFooter: "底栏嵌入输入框",
 			thinkingPeek: "思考预览",
+			toolView: "工具视图",
 			language: "语言",
 			cursorStyle: "光标样式",
 			iconMode: "图标模式",
@@ -95,6 +100,7 @@ const COPY = {
 			on: "开启",
 			off: "关闭",
 			thinkingPeek: { off: "关闭", one: "单行", two: "双行" },
+			toolView: { native: "原生", compact: "紧凑" },
 			languages: { en: "English", zh: "简体中文" },
 			cursorStyles: { block: "块", bar: "竖线", underline: "下划线" },
 			icons: { auto: "自动", nerd: "Nerd", unicode: "Unicode", ascii: "ASCII" },
@@ -160,9 +166,11 @@ function buildFeaturesItems(config: OpenTuiConfig, copy: SettingsCopy): SettingI
 	const flag = (value: boolean) => value ? copy.values.on : copy.values.off;
 	return [
 		{ id: "enabled", label: copy.labels.enabled, currentValue: flag(config.enabled) },
+		{ id: "header", label: copy.labels.header, currentValue: flag(config.header) },
 		{ id: "settingsLanguage", label: copy.labels.language, currentValue: copy.values.languages[config.settingsLanguage] },
 		{ id: "thinkingPeek", label: copy.labels.thinkingPeek, currentValue: formatThinkingPeekLines(config.thinkingPeek.lines, copy) },
 		{ id: "inlineFooter", label: copy.labels.inlineFooter, currentValue: flag(config.inlineFooter) },
+		{ id: "toolView", label: copy.labels.toolView, currentValue: copy.values.toolView[config.toolView.mode] },
 	];
 }
 
@@ -225,9 +233,13 @@ function handleSettingChange(
 ): OpenTuiConfig {
 	if (tab === "features") {
 		if (itemId === "enabled") return toggleEnabled(config);
+		if (itemId === "header") return { ...config, header: !config.header };
 		if (itemId === "inlineFooter") return { ...config, inlineFooter: !config.inlineFooter };
 		if (itemId === "settingsLanguage") return toggleLanguage(config);
 		if (itemId === "thinkingPeek") return cycleThinkingPeek(config);
+		if (itemId === "toolView") {
+			return { ...config, toolView: { mode: config.toolView.mode === "native" ? "compact" : "native" } };
+		}
 	}
 	if (tab === "icons") {
 		if (itemId === "mode") return cycleIconMode(config);

package/extensions/open-tui/tool-view.ts

@@ -0,0 +1,348 @@
+import { homedir } from "node:os";
+import { isAbsolute, relative, sep } from "node:path";
+import type { ExtensionAPI, Theme, ThemeColor, ToolRenderers } from "@earendil-works/pi-coding-agent";
+import { Box, type Component, Spacer, stripTerminalSequences, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { ToolViewMode } from "./config.ts";
+import type { IconGlyphs } from "./icons.ts";
+
+type RenderCall = NonNullable<ToolRenderers["renderCall"]>;
+type RenderResult = NonNullable<ToolRenderers["renderResult"]>;
+type RenderContext = Parameters<RenderCall>[2];
+type ToolResult = Parameters<RenderResult>[0];
+type Args = Record<string, unknown>;
+
+const TOOL_LABELS: Record<string, string> = {
+	read: "Read",
+	bash: "Bash",
+	powershell: "PowerShell",
+	edit: "Edit",
+	write: "Write",
+	grep: "Grep",
+	find: "Find",
+	ls: "LS",
+};
+const LIVE_TAIL_LINES = 3;
+
+/** Per-row slots: Pi's native renderers keep their own state and components here. */
+interface RowState {
+	nativeState: Record<string, unknown>;
+	nativeCall?: Component;
+	nativeResult?: Component;
+	callCard?: Box;
+	callCardBottom?: Spacer;
+	resultCard?: Box;
+	startedAt?: number;
+}
+
+const str = (value: unknown): string => (typeof value === "string" ? value : "");
+
+function plural(count: number, one: string, many = `${one}s`): string {
+	return `${count} ${count === 1 ? one : many}`;
+}
+
+/**
+ * Streaming shell output arrives raw: drop escape sequences and control characters as Pi does,
+ * and keep only the text after a lone `\r` so progress bars show their latest frame.
+ */
+function cleanOutput(text: string): string {
+	return stripTerminalSequences(text)
+		.replace(/\r\n/g, "\n")
+		.split("\n")
+		.map((line) => {
+			const frames = line.replace(/\r+$/, "");
+			return frames.slice(frames.lastIndexOf("\r") + 1);
+		})
+		.join("\n")
+		.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\uFFF9-\uFFFB]/g, "");
+}
+
+export function textOutput(result: ToolResult): string {
+	return cleanOutput(result.content.map((block) => (block.type === "text" ? block.text : "")).join("\n"));
+}
+
+/** Drops Pi's trailing `[...]` notice (truncation, limits, continuation hints) and the blank line before it. */
+export function stripNotice(text: string): string {
+	return text.replace(/\n\n\[[^\n]*\]\s*$/, "").replace(/\n+$/, "");
+}
+
+function countLines(text: string): number {
+	return text ? text.split("\n").length : 0;
+}
+
+export function diffStats(diff: string): { added: number; removed: number } {
+	let added = 0;
+	let removed = 0;
+	for (const line of diff.split("\n")) {
+		if (line.startsWith("+")) added++;
+		else if (line.startsWith("-")) removed++;
+	}
+	return { added, removed };
+}
+
+/** First command line, with a `… (+N lines)` hint for multi-line commands. */
+export function firstLine(text: string): string {
+	const lines = text.replace(/\r\n?/g, "\n").trim().split("\n");
+	const head = lines[0] ?? "";
+	return lines.length > 1 ? `${head} … (+${lines.length - 1} lines)` : head;
+}
+
+export function tailLines(text: string, count: number): string[] {
+	const lines = cleanOutput(text).split("\n").filter((line) => line.trim() !== "");
+	return lines.slice(-count);
+}
+
+/** `rel` when `path` is `base` or inside it; undefined for siblings such as `/home/sam-old`. */
+function inside(base: string, path: string): string | undefined {
+	const rel = relative(base, path);
+	return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel) ? rel.split(sep).join("/") : undefined;
+}
+
+export function displayPath(path: string, cwd: string, home = homedir()): string {
+	if (!path || !isAbsolute(path)) return path;
+	const inCwd = inside(cwd, path);
+	if (inCwd) return inCwd;
+	const inHome = inside(home, path);
+	return inHome === undefined ? path : inHome ? `~/${inHome}` : "~";
+}
+
+function lineRange(offset: unknown, limit: unknown): string {
+	if (typeof offset !== "number" && typeof limit !== "number") return "";
+	const start = typeof offset === "number" ? offset : 1;
+	return typeof limit === "number" ? `:${start}-${start + limit - 1}` : `:${start}`;
+}
+
+/** The single key argument shown inside `Tool(...)`. */
+export function callDetail(toolName: string, args: Args, cwd: string): string {
+	const path = displayPath(str(args.file_path ?? args.path), cwd);
+	switch (toolName) {
+		case "read":
+			return path + lineRange(args.offset, args.limit);
+		case "edit":
+		case "write":
+			return path;
+		case "bash":
+		case "powershell":
+			return firstLine(str(args.command));
+		case "grep": {
+			const pattern = str(args.pattern);
+			return pattern ? `/${pattern}/${path ? ` in ${path}` : ""}` : path;
+		}
+		case "find": {
+			const pattern = str(args.pattern);
+			return pattern && path ? `${pattern} in ${path}` : pattern || path;
+		}
+		case "ls":
+			return path || ".";
+		default:
+			return "";
+	}
+}
+
+function details(result: ToolResult): Record<string, unknown> {
+	const value: unknown = result.details;
+	return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : {};
+}
+
+function truncation(result: ToolResult): { truncated: boolean; totalLines?: number } {
+	const value = details(result).truncation;
+	if (typeof value !== "object" || value === null) return { truncated: false };
+	const { truncated, totalLines } = value as { truncated?: unknown; totalLines?: unknown };
+	return { truncated: truncated === true, totalLines: typeof totalLines === "number" ? totalLines : undefined };
+}
+
+/** Keeps the hint that a result is incomplete, which stripNotice drops from the text. */
+function incomplete(result: ToolResult): string {
+	const info = details(result);
+	const limit = ["matchLimitReached", "resultLimitReached", "entryLimitReached"].some((key) => info[key] !== undefined);
+	return (limit ? " · limit reached" : "") + (truncation(result).truncated ? " · truncated" : "");
+}
+
+/** Line count of shell output plus any incomplete-result hint. */
+function shellLines(output: string, result: ToolResult): string {
+	const text = output.trim();
+	const lines = text === "(no output)" ? 0 : truncation(result).totalLines ?? countLines(text);
+	return (lines === 0 ? "no output" : plural(lines, "line")) + incomplete(result);
+}
+
+/** One-line result summary for a finished, successful call. */
+export function summarizeResult(toolName: string, result: ToolResult, args: Args): string {
+	const raw = textOutput(result);
+	const text = stripNotice(raw);
+	switch (toolName) {
+		case "read": {
+			if (result.content.some((block) => block.type === "image")) return "image";
+			// An explicit `limit` that stops early adds this notice without setting details.truncation.
+			const more = /\n\n\[\d+ more lines in file\.[^\n]*\]\s*$/.test(raw) ? " · more" : "";
+			return plural(countLines(text), "line") + incomplete(result) + more;
+		}
+		case "bash":
+		case "powershell":
+			return `Done · ${shellLines(text, result)}`;
+		case "edit": {
+			const diff = details(result).diff;
+			if (typeof diff !== "string") return "Edited";
+			const { added, removed } = diffStats(diff);
+			return `+${added} −${removed}`;
+		}
+		case "write":
+			return `${plural(countLines(str(args.content).replace(/\n$/, "")), "line")} written`;
+		case "grep": {
+			if (text === "No matches found") return "No matches";
+			const files = new Set<string>();
+			let matches = 0;
+			for (const line of text.split("\n")) {
+				const match = /^(.+?):\d+: /.exec(line);
+				if (!match) continue;
+				matches++;
+				files.add(match[1]!);
+			}
+			return `${plural(matches, "match", "matches")} in ${plural(files.size, "file")}${incomplete(result)}`;
+		}
+		case "find":
+			return text === "No files found matching pattern" ? "No files" : plural(countLines(text), "file") + incomplete(result);
+		case "ls":
+			return text === "(empty directory)" ? "Empty" : plural(countLines(text), "entry", "entries") + incomplete(result);
+		default:
+			return "";
+	}
+}
+
+/**
+ * One-line summary for a failed call: the shell's closing status plus its last output line,
+ * otherwise the error's first line.
+ */
+export function summarizeError(toolName: string, result: ToolResult, duration = ""): string {
+	const text = textOutput(result).trim();
+	// Pi ends failed shell output with "Command exited with code N", "Command aborted", etc.
+	const status = toolName === "bash" || toolName === "powershell" ? /(?:^|\n\n)Command ([^\n]+)$/.exec(text) : null;
+	if (status) {
+		const reason = status[1]!;
+		const output = stripNotice(text.slice(0, status.index));
+		// The last output line usually names the failure; it goes last so narrow rows cut it first.
+		const last = tailLines(output, 1)[0]?.trim();
+		const tail = last && last !== "(no output)" ? ` · ${last}` : "";
+		return `${reason[0]!.toUpperCase()}${reason.slice(1)} · ${shellLines(output, result)}${duration}${tail}`;
+	}
+	return text.split("\n").find((line) => line.trim())?.trim() ?? "Failed";
+}
+
+function formatElapsed(ms: number): string {
+	return ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+
+/** Lines truncated to the render width; rebuilt on every render call. */
+function lines(build: (width: number) => string[]): Component {
+	return {
+		render: (width) => build(width).map((line) => truncateToWidth(line, Math.max(1, width), "…")),
+		invalidate() {},
+	};
+}
+
+function rowState(context: RenderContext): RowState {
+	const state = context.state as Partial<RowState>;
+	state.nativeState ??= {};
+	return state as RowState;
+}
+
+function nativeContext(context: RenderContext, row: RowState, lastComponent: Component | undefined): RenderContext {
+	return { ...context, state: row.nativeState, lastComponent };
+}
+
+function statusBg(theme: Theme, context: RenderContext): (text: string) => string {
+	const bg = context.isPartial ? "toolPendingBg" : context.isError ? "toolErrorBg" : "toolSuccessBg";
+	return (text) => theme.bg(bg, text);
+}
+
+export function createCompactRenderers(
+	toolName: string,
+	native: ToolRenderers,
+	glyphs: () => IconGlyphs,
+): ToolRenderers {
+	const label = TOOL_LABELS[toolName] ?? toolName;
+	const isShell = toolName === "bash" || toolName === "powershell";
+	// Expanded rows hand off to Pi's own card so nothing is hidden.
+	const showNative = (context: RenderContext) => context.expanded;
+
+	return {
+		renderShell: "self",
+		renderCall(args, theme, context) {
+			const row = rowState(context);
+			// Always run the native renderer so its own state (timers, edit preview) stays current.
+			row.nativeCall = native.renderCall?.(args, theme, nativeContext(context, row, row.nativeCall));
+			if (context.executionStarted) row.startedAt ??= Date.now();
+			if (showNative(context) && row.nativeCall) {
+				if (native.renderShell === "self") return row.nativeCall;
+				// Recreate Pi's default card: top padding, call, then result (or bottom padding while pending).
+				row.callCard ??= new Box(context.outputPad, 0);
+				row.callCardBottom ??= new Spacer(1);
+				row.callCard.setBgFn(statusBg(theme, context));
+				row.callCard.setPaddingX(context.outputPad);
+				row.callCard.clear();
+				row.callCard.addChild(new Spacer(1));
+				row.callCard.addChild(row.nativeCall);
+				row.callCard.addChild(row.callCardBottom);
+				return row.callCard;
+			}
+			const color: ThemeColor = context.isError ? "error" : context.isPartial ? "warning" : "success";
+			const detail = callDetail(toolName, (args ?? {}) as Args, context.cwd);
+			const pad = " ".repeat(context.outputPad);
+			return lines(() => [
+				pad + theme.fg(color, glyphs().toolCall) + " " + theme.fg("toolTitle", theme.bold(label))
+					+ (detail ? theme.fg("muted", `(${detail})`) : ""),
+			]);
+		},
+
+		renderResult(result, options, theme, context) {
+			const row = rowState(context);
+			row.nativeResult = native.renderResult?.(result, options, theme, nativeContext(context, row, row.nativeResult));
+			if (showNative(context) && row.nativeResult) {
+				if (native.renderShell === "self") return row.nativeResult;
+				// The result now closes the card, so the call card drops its pending bottom padding.
+				if (row.callCard && row.callCardBottom) row.callCard.removeChild(row.callCardBottom);
+				row.resultCard ??= new Box(context.outputPad, 0);
+				row.resultCard.setBgFn(statusBg(theme, context));
+				row.resultCard.setPaddingX(context.outputPad);
+				row.resultCard.clear();
+				row.resultCard.addChild(row.nativeResult);
+				row.resultCard.addChild(new Spacer(1));
+				return row.resultCard;
+			}
+			const pad = " ".repeat(context.outputPad);
+			const args = (context.args ?? {}) as Args;
+			return lines(() => {
+				const { toolResult } = glyphs();
+				const gutter = `${pad}  ${theme.fg("dim", toolResult)}  `;
+				const indent = `${pad}  ${" ".repeat(visibleWidth(toolResult))}  `;
+				if (options.isPartial) {
+					if (!isShell) return [gutter + theme.fg("warning", "Running…")];
+					const tail = tailLines(textOutput(result), LIVE_TAIL_LINES).map((line) => theme.fg("toolOutput", line));
+					const elapsed = row.startedAt === undefined ? "" : ` ${formatElapsed(Date.now() - row.startedAt)}`;
+					return [...tail, theme.fg("warning", `Running…${elapsed}`)]
+						.map((line, index) => (index === 0 ? gutter : indent) + line);
+				}
+				const duration = isShell && context.durationMs !== undefined ? ` · ${formatElapsed(context.durationMs)}` : "";
+				if (context.isError) return [gutter + theme.fg("error", summarizeError(toolName, result, duration))];
+				const summary = summarizeResult(toolName, result, args);
+				if (toolName === "edit" && /^\+\d+ −\d+$/.test(summary)) {
+					const [added, removed] = summary.split(" ");
+					return [gutter + theme.fg("toolDiffAdded", added!) + " " + theme.fg("toolDiffRemoved", removed!)];
+				}
+				return [gutter + theme.fg("muted", summary + duration)];
+			});
+		},
+	};
+}
+
+const OWNED_TOOLS = new Set(Object.keys(TOOL_LABELS));
+
+/**
+ * Display-only: Pi's tools, execution, arguments and results are untouched. The mode is read
+ * when Pi builds a row, so switching it affects new rows only.
+ */
+export function registerToolView(pi: ExtensionAPI, getMode: () => ToolViewMode, glyphs: () => IconGlyphs): void {
+	pi.registerToolRenderer((toolName, next) => {
+		const native = next();
+		if (!native || !OWNED_TOOLS.has(toolName) || getMode() !== "compact") return native;
+		return createCompactRenderers(toolName, native, glyphs);
+	});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-open-tui",
-  "version": "0.3.13",
+  "version": "0.4.0",
   "description": "A polished TUI for Pi coding agent: animated logo header, Starship-style footer, rounded editor with model metadata, and prompt-box user messages.",
   "type": "module",
   "repository": {
@@ -25,7 +25,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node --test tests/settings-command.test.ts tests/footer.test.ts tests/editor.test.ts tests/telemetry.test.ts tests/peek.test.ts",
+    "test": "node --test tests/settings-command.test.ts tests/footer.test.ts tests/editor.test.ts tests/telemetry.test.ts tests/peek.test.ts tests/tool-view.test.ts",
     "typecheck": "tsc --noEmit"
   },
   "pi": {
@@ -35,9 +35,9 @@
     "image": "https://raw.githubusercontent.com/OldSuns/pi-open-tui/main/assets/preview_dashboard_1.png"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=1.0.0",
-    "@earendil-works/pi-ai": ">=1.0.0",
-    "@earendil-works/pi-tui": ">=1.0.0"
+    "@earendil-works/pi-coding-agent": ">=1.2.0",
+    "@earendil-works/pi-ai": ">=1.2.0",
+    "@earendil-works/pi-tui": ">=1.2.0"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-coding-agent": {
@@ -51,9 +51,9 @@
     }
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^1.0.0",
-    "@earendil-works/pi-ai": "^1.0.0",
-    "@earendil-works/pi-tui": "^1.0.0",
+    "@earendil-works/pi-coding-agent": "^1.2.0",
+    "@earendil-works/pi-ai": "^1.2.0",
+    "@earendil-works/pi-tui": "^1.2.0",
     "@types/node": "^22.0.0",
     "typescript": "^5.5.0"
   },