@heyhuynhgiabuu/pi-pretty 0.6.30 → 0.7.0

package/src/tools/ls.ts

@@ -1,7 +1,7 @@
 /* pi-pretty: ls tool -- directory listing with styled output. */
 
 import type { AgentToolResult, ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { BG_ERROR, FG_DIM, RST, resolveBaseBackground, TOOL_RESULT_INDENT } from "../config.js";
+import { BG_ERROR, FG_DIM, RST, resolveBaseBackground } from "../config.js";
 import { shortPath } from "../helpers.js";
 import {
 	fillToolBackground,
@@ -11,6 +11,7 @@ import {
 	renderToolMetrics,
 	renderTree,
 	setCollapsedToolTitle,
+	toolIndent,
 } from "../render.js";
 import { resolveTextCtor } from "../tui-text.js";
 import type { LsDetails, RenderCtxLike, SdkToolDef, TextContent, ThemeLike } from "../types.js";
@@ -60,8 +61,9 @@ export function registerLsTool(
 			let out = theme.fg("toolTitle", theme.bold("ls"));
 			if (path) out += ` ${theme.fg("accent", path)}`;
 			if (limit !== undefined && limit !== null) out += theme.fg("toolOutput", ` (limit ${limit})`);
+			const ind = toolIndent(ctx);
 			const renderTitle = (suffix = ""): string =>
-				fillToolBackground(`\n${TOOL_RESULT_INDENT}${out}${suffix}\n`, ctx.isError ? BG_ERROR : undefined);
+				fillToolBackground(`\n${ind}${out}${suffix}\n`, ctx.isError ? BG_ERROR : undefined, undefined, ind);
 			rememberToolTitle(ctx, text, renderTitle);
 			text.setText(renderTitle());
 			return text;
@@ -71,25 +73,29 @@ export function registerLsTool(
 			resolveBaseBackground(theme);
 
 			const text = ctx.lastComponent ?? new TC("", 0, 0);
+			const ind = toolIndent(ctx);
 			if (ctx.isError) {
-				text.setText(renderToolError(getText(result) || "Error", theme));
+				text.setText(renderToolError(getText(result) || "Error", theme, ind));
 				return text;
 			}
 			const d = result.details as LsDetails | undefined;
 			if (d?._type === "lsResult" && d.text) {
 				if (!ctx.expanded) {
-					const summary = `${FG_DIM}${d.entryCount} entries — ctrl+o to expand${RST}${renderToolMetrics(result)}`;
+					const summary = `${FG_DIM}${d.entryCount} entries — ctrl+o to expand${RST}${renderToolMetrics(result, ctx)}`;
 					if (setCollapsedToolTitle(ctx, text, ` ${summary}`)) return text;
-					text.setText(fillToolBody(`${TOOL_RESULT_INDENT}${summary}`));
+					text.setText(fillToolBody(`${ind}${summary}`, undefined, undefined, ind));
 					return text;
 				}
 				const rendered = renderTree(d.text, d.path)
 					.split("\n")
-					.map((l) => `${TOOL_RESULT_INDENT}${l}`)
+					.map((l) => `${ind}${l}`)
 					.join("\n");
 				text.setText(
 					fillToolBody(
-						`${TOOL_RESULT_INDENT}${FG_DIM}${d.entryCount} entries${RST}${renderToolMetrics(result)}\n${rendered}`,
+						`${ind}${FG_DIM}${d.entryCount} entries${RST}${renderToolMetrics(result, ctx)}\n${rendered}`,
+						undefined,
+						undefined,
+						ind,
 					),
 				);
 				return text;
@@ -97,7 +103,10 @@ export function registerLsTool(
 			const fc = result.content?.[0];
 			text.setText(
 				fillToolBody(
-					`${TOOL_RESULT_INDENT}${theme.fg("dim", fc && "text" in fc ? String(fc.text).slice(0, 120) : "done")}`,
+					`${ind}${theme.fg("dim", fc && "text" in fc ? String(fc.text).slice(0, 120) : "done")}`,
+					undefined,
+					undefined,
+					ind,
 				),
 			);
 			return text;

package/src/tools/read.ts

@@ -3,19 +3,9 @@
 import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import type { AgentToolResult, ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { getReadmePath } from "@earendil-works/pi-coding-agent";
-import {
-	BG_BASE,
-	BG_ERROR,
-	FG_DIM,
-	FG_LNUM,
-	FG_RULE,
-	RST,
-	resolveBaseBackground,
-	TOOL_RESULT_INDENT,
-	termWidth,
-} from "../config.js";
+import { BG_BASE, BG_ERROR, FG_DIM, FG_LNUM, FG_RULE, RST, resolveBaseBackground, termWidth } from "../config.js";
 import { normalizeLineEndings, shortPath } from "../helpers.js";
-import { fillToolBackground, fillToolBody, renderFileContent, renderToolError } from "../render.js";
+import { fillToolBackground, fillToolBody, renderFileContent, renderToolError, toolIndent } from "../render.js";
 import { resolveTextCtor } from "../tui-text.js";
 import type { ReadDetails, RenderCtxLike, SdkToolDef, TextContent, ThemeLike } from "../types.js";
 import { wrapExecuteWithMetrics } from "./metrics.js";
@@ -79,6 +69,7 @@ export function registerReadTool(
 		promptSnippet: sdkTool.promptSnippet,
 		promptGuidelines: sdkTool.promptGuidelines,
 		constrainedSampling: sdkTool.constrainedSampling,
+		outputSchema: sdkTool.outputSchema as ToolDefinition["outputSchema"],
 		renderShell: "self",
 
 		execute: wrapExecuteWithMetrics(async (tid, params, sig, _upd, ctx: ExtensionContext) => {
@@ -114,9 +105,10 @@ export function registerReadTool(
 				return text;
 			}
 
+			const ind = toolIndent(ctx);
 			const path = String(args.path ?? "");
 			const label = theme.fg("error", theme.bold("→ read"));
-			text.setText(fillToolBackground(`\n${TOOL_RESULT_INDENT}${label} ${theme.fg("toolTitle", path)}\n`, BG_ERROR));
+			text.setText(fillToolBackground(`\n${ind}${label} ${theme.fg("toolTitle", path)}\n`, BG_ERROR, undefined, ind));
 			return text;
 		},
 
@@ -125,9 +117,10 @@ export function registerReadTool(
 
 			const renderToken = nextReadRenderToken(ctx);
 			const text = ctx.lastComponent ?? new TC("", 0, 0);
+			const ind = toolIndent(ctx);
 
 			if (ctx.isError) {
-				text.setText(renderToolError(getText(result) || "Error", theme));
+				text.setText(renderToolError(getText(result) || "Error", theme, ind));
 				return text;
 			}
 
@@ -155,7 +148,7 @@ export function registerReadTool(
 				if (!ctx.expanded) {
 					if (skillName) {
 						const header = renderSkillHeader(skillName, false, theme);
-						text.setText(fillToolBody(`\n${TOOL_RESULT_INDENT}${header}\n`, BG_BASE));
+						text.setText(fillToolBody(`\n${ind}${header}\n`, BG_BASE, undefined, ind));
 						return text;
 					}
 					const docsLabel = getPiDocsLabel(filePath, cwd);
@@ -164,8 +157,10 @@ export function registerReadTool(
 						: `${theme.fg("toolTitle", theme.bold("→ read"))} ${theme.fg("toolTitle", p2)}`;
 					text.setText(
 						fillToolBody(
-							`\n${TOOL_RESULT_INDENT}${title}${theme.fg("dim", off2)} ${FG_DIM}${total} lines — ctrl+o to expand${RST}`,
+							`\n${ind}${title}${theme.fg("dim", off2)} ${FG_DIM}${total} lines — ctrl+o to expand${RST}`,
 							BG_BASE,
+							undefined,
+							ind,
 						),
 					);
 					return text;
@@ -175,7 +170,8 @@ export function registerReadTool(
 				const offset = d.offset || 0;
 				const nw = Math.max(3, String(offset + total).length);
 				const gw = nw + 3;
-				const cw = Math.max(1, tw - gw);
+				// Default pad 1 keeps its historical budget; extra padding is subtracted so rows do not grow.
+				const cw = Math.max(1, tw - gw - Math.max(0, ind.length - 1));
 
 				const header = skillName
 					? renderSkillHeader(skillName, true, theme)
@@ -189,27 +185,27 @@ export function registerReadTool(
 				};
 				const cachedHighlight = getCachedReadHighlight(ctx, highlightRequest);
 				if (cachedHighlight !== undefined) {
-					const highlighted = buildHighlightedRead(cachedHighlight, header, skillName, offset, nw, tw);
-					text.setText(fillToolBody(highlighted, BG_BASE));
+					const highlighted = buildHighlightedRead(cachedHighlight, header, skillName, offset, nw, tw, ind);
+					text.setText(fillToolBody(highlighted, BG_BASE, undefined, ind));
 					return text;
 				}
 
-				const out: string[] = ["", `${TOOL_RESULT_INDENT}${header}`, ""];
-				out.push(`${TOOL_RESULT_INDENT}${FG_RULE}${"─".repeat(tw - 1)}${RST}`);
+				const out: string[] = ["", `${ind}${header}`, ""];
+				out.push(`${ind}${FG_RULE}${"─".repeat(Math.max(1, tw - ind.length))}${RST}`);
 				for (let i = 0; i < show.length; i++) {
 					const ln = offset + i + 1;
 					const code = show[i] ?? "";
 					const display = code.length > cw ? `${code.slice(0, Math.max(0, cw - 1))}${FG_DIM}›${RST}` : code;
 					const lineNo = String(ln);
 					out.push(
-						`${TOOL_RESULT_INDENT}${FG_LNUM}${" ".repeat(Math.max(0, nw - lineNo.length))}${lineNo}${RST} ${FG_RULE}│${RST} ${display}${RST}`,
+						`${ind}${FG_LNUM}${" ".repeat(Math.max(0, nw - lineNo.length))}${lineNo}${RST} ${FG_RULE}│${RST} ${display}${RST}`,
 					);
 				}
 				if (total > maxShow) {
-					out.push(`${TOOL_RESULT_INDENT}${FG_DIM}… ${total - maxShow} more lines (${total} total)${RST}`);
+					out.push(`${ind}${FG_DIM}… ${total - maxShow} more lines (${total} total)${RST}`);
 				}
 				const rendered = out.join("\n");
-				text.setText(fillToolBody(rendered, BG_BASE));
+				text.setText(fillToolBody(rendered, BG_BASE, undefined, ind));
 
 				// Async syntax highlighting via Shiki. The component is reused across
 				// expansion changes, so stale work must not restore an older view.
@@ -217,8 +213,8 @@ export function registerReadTool(
 					.then((hl) => {
 						if (!isCurrentReadRender(ctx, renderToken)) return;
 						setCachedReadHighlight(ctx, highlightRequest, hl);
-						const highlighted = buildHighlightedRead(hl, header, skillName, offset, nw, tw);
-						text.setText(fillToolBody(highlighted, BG_BASE));
+						const highlighted = buildHighlightedRead(hl, header, skillName, offset, nw, tw, ind);
+						text.setText(fillToolBody(highlighted, BG_BASE, undefined, ind));
 						ctx.invalidate?.();
 					})
 					.catch(() => {});
@@ -229,8 +225,10 @@ export function registerReadTool(
 			const fc = result.content?.[0];
 			text.setText(
 				fillToolBody(
-					`${TOOL_RESULT_INDENT}${theme.fg("dim", fc && "text" in fc ? String(fc.text).slice(0, 120) : "done")}`,
+					`${ind}${theme.fg("dim", fc && "text" in fc ? String(fc.text).slice(0, 120) : "done")}`,
 					BG_BASE,
+					undefined,
+					ind,
 				),
 			);
 			return text;
@@ -293,16 +291,17 @@ function buildHighlightedRead(
 	offset: number,
 	nw: number,
 	tw: number,
+	ind: string,
 ): string {
 	const padded = highlighted
 		.split("\n")
 		.map((line, index) => {
 			const lineNo = String(offset + index + 1);
-			return `${TOOL_RESULT_INDENT}${FG_LNUM}${" ".repeat(Math.max(0, nw - lineNo.length))}${lineNo}${RST} ${FG_RULE}│${RST} ${line}${RST}`;
+			return `${ind}${FG_LNUM}${" ".repeat(Math.max(0, nw - lineNo.length))}${lineNo}${RST} ${FG_RULE}│${RST} ${line}${RST}`;
 		})
 		.join("\n");
-	const divider = skillName ? `${TOOL_RESULT_INDENT}${FG_RULE}${"─".repeat(Math.max(1, tw - 1))}${RST}\n` : "";
-	return `\n${TOOL_RESULT_INDENT}${header}\n\n${divider}${padded}`;
+	const divider = skillName ? `${ind}${FG_RULE}${"─".repeat(Math.max(1, tw - ind.length))}${RST}\n` : "";
+	return `\n${ind}${header}\n\n${divider}${padded}`;
 }
 
 function getText(result: Result): string {

package/src/types.ts

@@ -34,7 +34,16 @@ export interface RenderCtxLike {
 	isError?: boolean;
 	state: Record<string, unknown>;
 	expanded?: boolean;
+	/** Tool call arguments as streamed so far. */
+	args?: Record<string, unknown>;
+	isPartial?: boolean;
+	/** False while the tool call is still streaming its arguments. */
+	executionStarted?: boolean;
 	invalidate?: () => void;
+	/** Host horizontal padding (pi >= 1.1). Absent on older hosts; renderers fall back to 1. */
+	outputPad?: number;
+	/** Final host-measured execution time in ms; undefined while running or on older hosts. */
+	durationMs?: number;
 }
 
 export interface TextLike {

package/src/working-indicator.ts

@@ -14,6 +14,7 @@
  * phase. The extension adds no interrupt hint or token-count suffix.
  */
 
+import { keyText } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import { FG_BLUE, FG_DIM, FG_MUTED, type ThinkingIndicatorConfig, type WorkingIndicatorConfig } from "./config.js";
 import { dimAccentHex, hexToAnsiFg, sessionAccentHex } from "./session-color.js";
@@ -539,7 +540,7 @@ export function installPerRowThinkingLabels(componentClass: unknown): PerRowThin
 			if (typeof ts !== "number") return incoming;
 			if (ts === state.activeTs) return incoming;
 			const ms = state.completed.get(ts);
-			return ms === undefined ? THINKING_LABEL : `${THOUGHT_LABEL} ${formatThinkingDuration(ms)}`;
+			return ms === undefined ? thinkingLabel() : thoughtLabel(ms);
 		} catch {
 			return incoming;
 		}
@@ -588,9 +589,20 @@ export interface ThinkingTimer {
 	restore(): void;
 }
 
-const THINKING_LABEL = " Thinking...";
-const THOUGHT_LABEL = " Thought for";
-const padThinkingLabel = (label: string): string => (label.startsWith(" ") ? label : ` ${label}`);
+let claudeThinkingLabels = false;
+/** claudecode tool style: flush-left `thinking` / `thought 3s` instead of ` Thinking...` / ` Thought for 3s`. */
+export function setClaudeThinkingLabels(enabled: boolean): void {
+	claudeThinkingLabels = enabled;
+}
+const thinkingLabel = (): string => (claudeThinkingLabels ? "thinking" : " Thinking...");
+const padThinkingLabel = (label: string): string =>
+	claudeThinkingLabels || label.startsWith(" ") ? label : ` ${label}`;
+/** Settled label for a finished thinking run; claudecode style appends the toggle hint when bound. */
+const thoughtLabel = (ms: number): string => {
+	if (!claudeThinkingLabels) return ` Thought for ${formatThinkingDuration(ms)}`;
+	const key = keyText("app.thinking.toggle");
+	return `thought ${formatThinkingDuration(ms)}${key ? ` (${key} to expand)` : ""}`;
+};
 
 /** Format sub-second elapsed time as milliseconds, then use compact whole seconds. */
 export function formatThinkingDuration(elapsedMs: number): string {
@@ -626,13 +638,13 @@ export function createThinkingTimer(
 	return {
 		tick(): void {
 			if (terminal) return;
-			animator.tick(`${THINKING_LABEL} ${duration()}`);
+			animator.tick(`${thinkingLabel()} ${duration()}`);
 		},
 		complete(): number | undefined {
 			if (terminal) return undefined;
 			terminal = true;
 			const ms = elapsed();
-			animator.show(`${THOUGHT_LABEL} ${formatThinkingDuration(ms)}`);
+			animator.show(thoughtLabel(ms));
 			return ms;
 		},
 		restore(): void {
@@ -702,7 +714,7 @@ export function createThinkingLabelAnimator(
 		}).frames.map((frame) => `${leftPadding}${frame}`);
 	};
 
-	let currentLabel = THINKING_LABEL;
+	let currentLabel = thinkingLabel();
 	let frames = buildLabelFrames(currentLabel);
 
 	let index = 0;
@@ -711,7 +723,7 @@ export function createThinkingLabelAnimator(
 		get frames(): readonly string[] {
 			return frames;
 		},
-		tick(label = THINKING_LABEL): void {
+		tick(label = thinkingLabel()): void {
 			const paddedLabel = padThinkingLabel(label);
 			if (paddedLabel !== currentLabel) {
 				frames = buildLabelFrames(paddedLabel);