@quandev104/pi-style 0.1.7 → 0.2.0

package/extension-src/pi-style/app/command-service.ts

@@ -56,6 +56,7 @@ const allowedPaths = new Set([
 	"tools.dimOutput",
 	"tools.showElapsed",
 	"tools.collapseAfterTurn",
+	"tools.collapseMutatingTools",
 	"theme.nerdFonts",
 	"theme.terminalBackgroundSync",
 	"theme.autoApply",
@@ -85,6 +86,7 @@ function validatePathValue(path: string, value: unknown): boolean {
 			"tools.showElapsed",
 			"tools.dimOutput",
 			"tools.collapseAfterTurn",
+			"tools.collapseMutatingTools",
 			"compatibility.allowSafePatches",
 			"compatibility.allowCorePatches",
 			"compatibility.preferExistingEditor",

package/extension-src/pi-style/domain/config-normalization.ts

@@ -43,6 +43,7 @@ export const DEFAULT_CONFIG: NormalizedPiStyleConfig = Object.freeze({
 		dimOutput: false,
 		showElapsed: true,
 		collapseAfterTurn: true,
+		collapseMutatingTools: false,
 	}),
 	theme: Object.freeze({
 		nerdFonts: "auto",
@@ -186,6 +187,7 @@ export function normalizeConfig(
 			dimOutput: bool(tools.dimOutput, defaults.tools.dimOutput),
 			showElapsed: bool(tools.showElapsed, defaults.tools.showElapsed),
 			collapseAfterTurn: bool(tools.collapseAfterTurn, defaults.tools.collapseAfterTurn),
+			collapseMutatingTools: bool(tools.collapseMutatingTools, defaults.tools.collapseMutatingTools),
 		}),
 		theme: Object.freeze({
 			nerdFonts: stringEnum(theme.nerdFonts, ["auto", "on", "off"], defaults.theme.nerdFonts),
@@ -241,6 +243,7 @@ const BOOL_PATHS = new Set([
 	"tools.showElapsed",
 	"tools.dimOutput",
 	"tools.collapseAfterTurn",
+	"tools.collapseMutatingTools",
 	"compatibility.allowSafePatches",
 	"compatibility.allowCorePatches",
 	"compatibility.preferExistingEditor",

package/extension-src/pi-style/domain/config-types.ts

@@ -48,6 +48,8 @@ export interface PiStyleConfig {
 		showElapsed?: boolean;
 		/** Collapse a completed turn's tool blocks into one summary line (ADR 0007). */
 		collapseAfterTurn?: boolean;
+		/** Also collapse mutating tools (edit/write/…) into the summary; off keeps them visible. */
+		collapseMutatingTools?: boolean;
 	};
 	theme?: {
 		nerdFonts?: string;
@@ -105,6 +107,8 @@ export interface NormalizedPiStyleConfig {
 		showElapsed: boolean;
 		/** Collapse a completed turn's tool blocks into one summary line (ADR 0007). */
 		collapseAfterTurn: boolean;
+		/** Also collapse mutating tools (edit/write/…) into the summary; off keeps them visible. */
+		collapseMutatingTools: boolean;
 	};
 	readonly theme: {
 		nerdFonts: NerdFontsMode;

package/extension-src/pi-style/features/tools/boxed/index.ts

@@ -20,6 +20,7 @@ import type { BoxedToolContext, BoxedToolDefinition } from "./shared.js";
 import {
 	emptyTurnResult,
 	getTurnEntry,
+	isMutatingTool,
 	noteTurnMemberElapsed,
 	noteTurnMemberRender,
 	renderTurnSummaryCall,
@@ -53,12 +54,16 @@ export function hasBoxedRenderer(toolName: unknown): boolean {
 /**
  * Turn-summary gate (ADR 0007): the member belongs to an ended turn, Pi's
  * global tool-output state is collapsed, the surface is enabled, and the block
- * itself is not an error (errors always stay visible).
+ * itself is not an error (errors always stay visible). Mutating tools
+ * (edit/write/…) are exempt unless `tools.collapseMutatingTools` is on — their
+ * blocks are the record of what was done and stay visible by default.
  */
 function collapsedTurnFor(toolCallId: string, expanded: boolean): TurnState | undefined {
-	if (expanded || !getToolsRenderConfig().collapseAfterTurn) return undefined;
+	const config = getToolsRenderConfig();
+	if (expanded || !config.collapseAfterTurn) return undefined;
 	const entry = getTurnEntry(toolCallId);
 	if (!entry?.turn.ended || entry.member.isError) return undefined;
+	if (isMutatingTool(entry.member.toolName) && !config.collapseMutatingTools) return undefined;
 	return entry.turn;
 }
 

package/extension-src/pi-style/features/tools/boxed/session-config.ts

@@ -14,6 +14,8 @@ export interface ToolsRenderConfig {
 	nerdFonts: boolean;
 	/** Collapse a completed turn's tool blocks into one summary line (ADR 0007). */
 	collapseAfterTurn: boolean;
+	/** Also collapse mutating tools (edit/write/…) into the summary; off keeps them visible. */
+	collapseMutatingTools: boolean;
 }
 
 let sessionToolsConfig: ToolsRenderConfig = {
@@ -24,6 +26,7 @@ let sessionToolsConfig: ToolsRenderConfig = {
 	batchOpenGlyph: "●",
 	nerdFonts: false,
 	collapseAfterTurn: true,
+	collapseMutatingTools: false,
 };
 
 export function setToolsRenderConfig(config: Partial<ToolsRenderConfig>): void {

package/extension-src/pi-style/features/tools/boxed/turn-summary.ts

@@ -2,10 +2,18 @@
 //
 // When a turn completes, its finalized tool blocks collapse into a single
 // summary line (`➔ Read 2 files, ran 4 shell commands · 3.1s`) rendered by the
-// turn's leader (its first non-error tool call); every other non-error tool
-// item of the turn renders zero lines. Error results stay visible, interrupted
-// turns never collapse, and Pi's global tool-output toggle (Ctrl+O) expands
-// everything again (`options.expanded` is read, never written).
+// turn's leader (its first non-error tool call that collapses under the render
+// config); every other collapsible tool item of the turn renders zero lines.
+// Error results stay visible, interrupted turns never collapse, and Pi's
+// global tool-output toggle (Ctrl+O) expands everything again
+// (`options.expanded` is read, never written).
+//
+// Mutating tools (edit/write/quick_edit/substitute_edit/target_edit) are
+// exempt from the summary by default (`tools.collapseMutatingTools: off`):
+// their blocks are the record of what was done to the user's files, so they
+// always stay visible (compact preview) even in an ended turn — the summary
+// covers only read-only tools (read/ls/find/grep/bash). Turning the leaf on
+// restores the full collapse.
 //
 // Design notes:
 // - The registry is populated from **session content**, never from runtime
@@ -27,6 +35,7 @@ import type { Component } from "@earendil-works/pi-tui";
 import type { BoxTheme } from "../../../shared/box.js";
 import { safeTruncateToWidth } from "../../../shared/render-budget.js";
 import { pluralForm } from "./output-tree.js";
+import { getToolsRenderConfig } from "./session-config.js";
 
 export interface TurnMemberInfo {
 	readonly toolCallId: string;
@@ -39,12 +48,37 @@ export interface TurnMemberInfo {
 }
 
 export interface TurnState {
-	/** First non-error member; renders the summary line. Empty when every member errored. */
+	/**
+	 * First non-error member that collapses under the current render config
+	 * (mutating members are skipped unless `tools.collapseMutatingTools` is
+	 * on); renders the summary line. Empty when every member errored or when
+	 * the turn's members are all mutating with the exemption active (such a
+	 * turn collapses nothing).
+	 */
 	leaderId: string;
 	ended: boolean;
 	members: readonly TurnMemberInfo[];
 }
 
+/**
+ * Tools that change the user's files. Their blocks are the record of what was
+ * done — they stay visible after the turn and are excluded from the summary
+ * unless `tools.collapseMutatingTools` is on. bash is deliberately NOT here:
+ * read-only and mutating commands are indistinguishable without parsing the
+ * command text.
+ */
+const MUTATING_TOOLS: ReadonlySet<string> = new Set(["edit", "write", "quick_edit", "substitute_edit", "target_edit"]);
+
+/** Whether the tool changes the user's files (exempt from turn collapse). */
+export function isMutatingTool(toolName: string): boolean {
+	return MUTATING_TOOLS.has(toolName);
+}
+
+/** Whether the summary should also cover mutating tools (render config). */
+function mutatingCollapses(): boolean {
+	return getToolsRenderConfig().collapseMutatingTools;
+}
+
 interface TurnEntry {
 	readonly turn: TurnState;
 	readonly member: TurnMemberInfo;
@@ -96,7 +130,7 @@ function registerTurn(
 			isError: isErrorById.get(toolCallId) === true,
 		};
 	});
-	const leader = members.find((member) => !member.isError);
+	const leader = members.find((member) => !member.isError && (!isMutatingTool(member.toolName) || mutatingCollapses()));
 	const turn: TurnState = {
 		leaderId: leader?.toolCallId ?? "",
 		ended: ended && complete,
@@ -145,7 +179,9 @@ export function registerTurnFromMessage(message: unknown, toolResults: readonly
 			isError: isErrorById.get(toolCallId) === true,
 		};
 	});
-	const leader = newMembers.find((member) => !member.isError);
+	const leader = newMembers.find(
+		(member) => !member.isError && (!isMutatingTool(member.toolName) || mutatingCollapses()),
+	);
 	if (!currentRun) {
 		currentRun = {
 			leaderId: leader?.toolCallId ?? "",
@@ -303,17 +339,24 @@ export interface TurnSummaryParts {
 	readonly elapsedMs: number | undefined;
 }
 
-/** Aggregate a turn's non-error members into summary parts (pure). */
+/**
+ * Aggregate a turn's collapsed members into summary parts (pure). Mutating
+ * members are excluded unless `tools.collapseMutatingTools` is on — by default
+ * their visible blocks are the record; the summary describes only what it
+ * hides.
+ */
 export function turnSummaryParts(turn: TurnState): TurnSummaryParts {
 	const counts = new Map<string, number>();
 	const order: string[] = [];
 	let failedCount = 0;
 	let elapsedMs: number | undefined;
+	const collapseMutating = mutatingCollapses();
 	for (const member of turn.members) {
 		if (member.isError) {
 			failedCount++;
 			continue;
 		}
+		if (!collapseMutating && isMutatingTool(member.toolName)) continue;
 		if (member.elapsedMs !== undefined) elapsedMs = (elapsedMs ?? 0) + member.elapsedMs;
 		const existing = counts.get(member.toolName);
 		if (existing === undefined) {
@@ -323,8 +366,10 @@ export function turnSummaryParts(turn: TurnState): TurnSummaryParts {
 	}
 	const parts = order.map((toolName) => {
 		const count = counts.get(toolName) ?? 0;
-		const style = TURN_SUMMARY_STYLE[toolName] ?? { verb: "ran", unit: `${toolName} call` };
-		return `${style.verb} ${count} ${pluralForm(style.unit, count)}`;
+		const style = TURN_SUMMARY_STYLE[toolName];
+		// Unknown tools (extension tools like TaskCreate/ask_user_question) use a
+		// neutral phrasing with the invariant tool name: `used 5 TaskCreate`.
+		return style ? `${style.verb} ${count} ${pluralForm(style.unit, count)}` : `used ${count} ${toolName}`;
 	});
 	return { parts, failedCount, elapsedMs };
 }
@@ -337,7 +382,7 @@ function formatTurnSummaryLine(theme: BoxTheme, turn: TurnState): string {
 	const parts = summary.parts.join(", ");
 	let line = `${theme.fg("dim", `➔ ${parts}`)}`;
 	if (summary.failedCount > 0)
-		line += theme.fg("error", ` · ${summary.failedCount} ${pluralForm("failed", summary.failedCount)}`);
+		line += theme.fg("error", ` · ${summary.failedCount} ${pluralForm("failure", summary.failedCount)}`);
 	if (summary.elapsedMs !== undefined) line += theme.fg("dim", ` · ${(summary.elapsedMs / 1000).toFixed(2)}s`);
 	return line;
 }

package/extension-src/pi-style/features/tools/index.ts

@@ -423,16 +423,31 @@ export function createToolDecorationOwner(snapshot: Partial<ToolDecorationSnapsh
 				if (typeof renderer !== "function") {
 					neutralizeToolContainerBackground(instance);
 					if (subtype === "tool-call-renderer")
-						return (callArgs: unknown, theme: unknown, context: unknown) =>
-							renderBoxedToolCall(toolName, callArgs as Record<string, unknown>, theme as never, context as never);
-					return (result: unknown, options: unknown, theme: unknown, context: unknown) =>
-						renderBoxedToolResult(
+						return (callArgs: unknown, theme: unknown, context: unknown) => {
+							const component = renderBoxedToolCall(
+								toolName,
+								callArgs as Record<string, unknown>,
+								theme as never,
+								context as never,
+							);
+							// Same batch-member contract as the native-renderer path: a
+							// collapsed turn member (or quiet batch member) returns the
+							// singleton and must be hidden, or Pi leaves a stray native
+							// placeholder row per block after the collapse.
+							if (component === EMPTY_BATCH_COMPONENT) hideBatchMember(instance);
+							return component;
+						};
+					return (result: unknown, options: unknown, theme: unknown, context: unknown) => {
+						const component = renderBoxedToolResult(
 							toolName,
 							result as { content?: readonly unknown[]; details?: unknown },
 							options as { expanded: boolean; isPartial: boolean },
 							theme as never,
 							context as never,
 						);
+						if (component === EMPTY_BATCH_COMPONENT) hideBatchMember(instance);
+						return component;
+					};
 				}
 				return function (this: unknown, ...rendererArgs: unknown[]) {
 					const valid = subtype === "tool-call-renderer" ? validCallArgs(rendererArgs) : validResultArgs(rendererArgs);

package/extension-src/pi-style/shared/box.ts

@@ -567,8 +567,20 @@ function renderBoxedOutputLines(
 	let truncated = false;
 
 	for (; nextInputIndex < outputLines.length; nextInputIndex++) {
-		const line = boxedTruncatedLine(theme, outputLines[nextInputIndex] ?? "", width);
-		if (!pushBoundedLines(head, [line], headLimit)) {
+		// An output "line" may carry embedded newlines (raw tool error messages,
+		// JSON payloads). Split before boxing so every fragment gets its own
+		// border and truncation — otherwise the box frame visually breaks on the
+		// embedded rows.
+		const fragments = (outputLines[nextInputIndex] ?? "").split("\n");
+		let headExceeded = false;
+		for (const fragment of fragments) {
+			const line = boxedTruncatedLine(theme, fragment, width);
+			if (!pushBoundedLines(head, [line], headLimit)) {
+				headExceeded = true;
+				break;
+			}
+		}
+		if (headExceeded) {
 			truncated = true;
 			nextInputIndex++;
 			break;
@@ -580,9 +592,12 @@ function renderBoxedOutputLines(
 	const tail: string[] = [];
 	const tailStart = Math.max(nextInputIndex, outputLines.length - tailLimit);
 	for (let i = tailStart; i < outputLines.length; i++) {
-		const line = boxedTruncatedLine(theme, outputLines[i] ?? "", width);
-		tail.push(line);
-		if (tail.length > tailLimit) tail.splice(0, tail.length - tailLimit);
+		const fragments = (outputLines[i] ?? "").split("\n");
+		for (const fragment of fragments) {
+			const line = boxedTruncatedLine(theme, fragment, width);
+			tail.push(line);
+			if (tail.length > tailLimit) tail.splice(0, tail.length - tailLimit);
+		}
 	}
 
 	const skippedInputLines = Math.max(0, tailStart - nextInputIndex);
@@ -764,6 +779,10 @@ export function renderBoxedToolResult(
 				bodyLines.length > 0
 					? [...errorPrefix, ...bodyLines]
 					: [theme.fg("muted", `∅ ${options.emptyText ?? "(no output)"}`)];
+			// Split embedded newlines before budgeting so raw multi-line messages
+			// (tool validation errors, JSON payloads) render as proper bordered
+			// rows instead of one "line" whose embedded rows break the frame.
+			const outputFragments = outputLines.flatMap((line) => line.split("\n"));
 			const footerText = (options.footerLines ?? []).join(" · ");
 			const dividerText =
 				typeof options.dividerLabel === "function"
@@ -783,7 +802,12 @@ export function renderBoxedToolResult(
 							),
 						]),
 				boxBlankLine(theme, renderedWidth),
-				...renderBoxedOutputLines(theme, outputLines, renderedWidth, options.renderLineBudget ?? outputLines.length),
+				...renderBoxedOutputLines(
+					theme,
+					outputFragments,
+					renderedWidth,
+					options.renderLineBudget ?? outputFragments.length,
+				),
 				boxBlankLine(theme, renderedWidth),
 				boxLabeledBorder(
 					theme,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quandev104/pi-style",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "description": "A native-layout, cohesive visual style package for Pi.",
   "license": "MIT",
   "type": "module",