@owlburtoe/pi-cc-tools 1.0.1 → 1.1.1

package/README.md

@@ -5,6 +5,7 @@ Claude Code inspired tool rendering for Pi — Shiki-powered diffs, status dots,
 ## Features
 
 - **Compact built-in tool rendering** for `read`, `bash`, `grep`, `find`, `ls`, `edit`, and `write`
+- **Semantic bash display** that renders common read-only shell one-liners like `nl -ba file | sed -n '1,200p'` as Claude Code-style `Read file (lines 1-200)` rows
 - **Claude-style OpenAI tool rendering** for `apply_patch` plus common Pi/OpenAI-style tools like `webfetch`, `web_search`, `fetch_content`, task tools, and context tools
 - **`apply_patch` diff previews** that render parsed file patches in the call phase, similar to `edit`/`write`
 - **Adaptive edit/write diffs** with split or unified layouts, syntax highlighting, and inline word-level emphasis
@@ -32,6 +33,8 @@ Set in `.pi/settings.json` or `~/.pi/settings.json`:
   "previewLines": 8,
   "bashOutputMode": "opencode",
   "bashCollapsedLines": 10,
+  "bashStackConsecutive": true,
+  "bashSemanticDisplay": true,
   "diffCollapsedLines": 24,
   "themeAdaptive": true,
   "diffTheme": "github-dark",
@@ -135,6 +138,21 @@ Color selections are persisted as `spinnerColor` / `spinnerStatusColor` in `~/.p
 | `mcpOutputMode` | `hidden`, `summary`, `preview` | `preview` |
 | `bashOutputMode` | `opencode`, `summary`, `preview` | `opencode` |
 
+`bashOutputMode` behavior:
+
+| Value | Behavior |
+|-------|----------|
+| `opencode` | Compact status while collapsed, with `Ctrl+O` hint for output preview on raw shell commands. Semantic read-only bash rows omit the repeated hint to stay closer to Claude Code. |
+| `summary` | Status only; no output preview or expansion hint |
+| `preview` | Show a small output preview even while collapsed |
+
+### Boolean settings
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `bashStackConsecutive` | `true` | Remove the extra synthetic spacer between adjacent bash tool rows so command bursts render as a tight stack |
+| `bashSemanticDisplay` | `true` | Render common read-only shell file-inspection commands as semantic `Read` rows instead of raw `Bash` rows |
+
 ### Numeric settings
 
 | Setting | Default | Description |

package/config/config.example.json

@@ -7,6 +7,8 @@
   "expandedPreviewMaxLines": 4000,
   "bashOutputMode": "opencode",
   "bashCollapsedLines": 10,
+  "bashStackConsecutive": true,
+  "bashSemanticDisplay": true,
   "diffCollapsedLines": 24,
   "showTruncationHints": false,
   "themeAdaptive": true,

package/extensions/index.ts

@@ -84,6 +84,10 @@ interface SettingsFile {
 	expandedPreviewMaxLines?: number;
 	bashOutputMode?: "opencode" | "summary" | "preview";
 	bashCollapsedLines?: number;
+	/** When true (default), consecutive bash tool rows render without the extra inter-tool spacer. */
+	bashStackConsecutive?: boolean;
+	/** When true (default), read-only shell file-inspection one-liners render as semantic Read rows instead of raw Bash rows. */
+	bashSemanticDisplay?: boolean;
 	showTruncationHints?: boolean;
 	diffCollapsedLines?: number;
 	diffTheme?: string;
@@ -329,6 +333,44 @@ function isToolExecutionLike(value: unknown): value is { toolName: string; toolC
 	return typeof candidate.toolName === "string" && typeof candidate.toolCallId === "string";
 }
 
+function isBashToolExecution(value: unknown): boolean {
+	return isToolExecutionLike(value) && (value as any).toolName === "bash";
+}
+
+function shouldStackConsecutiveBash(): boolean {
+	return readSettings().bashStackConsecutive !== false;
+}
+
+function hasConsecutiveBashToolChildren(children: unknown[]): boolean {
+	let previousWasBash = false;
+	for (const child of children) {
+		const currentIsBash = isBashToolExecution(child);
+		if (currentIsBash && previousWasBash) return true;
+		previousWasBash = currentIsBash;
+	}
+	return false;
+}
+
+function dropLeadingSpacerLine(lines: string[]): string[] {
+	return lines.length > 0 && isBlankLine(lines[0]) ? lines.slice(1) : lines;
+}
+
+function renderWithStackedConsecutiveBash(container: any, width: number): string[] | null {
+	if (!shouldStackConsecutiveBash()) return null;
+	const children = Array.isArray(container?.children) ? container.children : null;
+	if (!children || !hasConsecutiveBashToolChildren(children)) return null;
+
+	const rendered: string[] = [];
+	let previousWasBash = false;
+	for (const child of children) {
+		const currentIsBash = isBashToolExecution(child);
+		const childLines = typeof child?.render === "function" ? child.render(width) : [];
+		rendered.push(...(currentIsBash && previousWasBash ? dropLeadingSpacerLine(childLines) : childLines));
+		previousWasBash = currentIsBash;
+	}
+	return rendered;
+}
+
 function isTerminalImageLine(line: string): boolean {
 	return line.includes(KITTY_IMAGE_PREFIX) || line.includes(ITERM2_IMAGE_PREFIX);
 }
@@ -359,6 +401,11 @@ function patchGlobalToolBorders(): void {
 
 	const originalRender = proto.render;
 	proto.render = function patchedContainerRender(width: number): string[] {
+		if (!isToolExecutionLike(this)) {
+			const stacked = renderWithStackedConsecutiveBash(this, width);
+			if (stacked) return stacked;
+		}
+
 		if (isToolExecutionLike(this)) {
 			const cached = (this as any)[TOOL_RENDER_CACHE];
 			if (cached?.width === width && cached?.mode === toolBackgroundMode) {
@@ -1324,6 +1371,195 @@ function bashCollapsedLimit(): number {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : 10;
 }
 
+function bashOutputMode(): "opencode" | "summary" | "preview" {
+	return getMode(readSettings().bashOutputMode, ["opencode", "summary", "preview"] as const, "opencode");
+}
+
+function bashSemanticDisplayEnabled(): boolean {
+	return readSettings().bashSemanticDisplay !== false;
+}
+
+export interface BashDisplayInfo {
+	kind: "read";
+	label: "Read";
+	path: string;
+	rangeLabel?: string;
+	suppressCollapsedHint: boolean;
+}
+
+function tokenizeShellCommand(command: string): string[] | null {
+	const tokens: string[] = [];
+	let current = "";
+	let quote: "'" | '"' | null = null;
+	let escaping = false;
+
+	const push = () => {
+		if (current.length > 0) {
+			tokens.push(current);
+			current = "";
+		}
+	};
+
+	for (let i = 0; i < command.length; i++) {
+		const char = command[i];
+		if (escaping) {
+			current += char;
+			escaping = false;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) {
+				quote = null;
+				continue;
+			}
+			if (quote === '"' && char === "\\") {
+				escaping = true;
+				continue;
+			}
+			current += char;
+			continue;
+		}
+		if (char === "\\") {
+			escaping = true;
+			continue;
+		}
+		if (char === "'" || char === '"') {
+			quote = char;
+			continue;
+		}
+		if (/\s/.test(char)) {
+			push();
+			continue;
+		}
+		if (char === "|" || char === ";") {
+			push();
+			if (char === "|" && command[i + 1] === "|") {
+				tokens.push("||");
+				i++;
+			} else {
+				tokens.push(char);
+			}
+			continue;
+		}
+		if (char === "&" && command[i + 1] === "&") {
+			push();
+			tokens.push("&&");
+			i++;
+			continue;
+		}
+		current += char;
+	}
+	if (escaping) current += "\\";
+	if (quote) return null;
+	push();
+	return tokens;
+}
+
+function isControlToken(token: string): boolean {
+	return token === "&&" || token === "||" || token === ";";
+}
+
+function isOptionToken(token: string): boolean {
+	return token.startsWith("-") && token !== "-" && token !== "--";
+}
+
+function singlePathArg(tokens: readonly string[]): string | null {
+	const paths = tokens.filter((token) => token !== "--" && token !== "-" && !isOptionToken(token));
+	return paths.length === 1 ? paths[0] : null;
+}
+
+function formatSedRangeLabel(script: string | undefined): string | undefined {
+	if (!script) return undefined;
+	const match = script.match(/^(\d+|\$)(?:,(\d+|\$))?p$/);
+	if (!match) return undefined;
+	const start = match[1];
+	const end = match[2];
+	if (!end || end === start) return `line ${start}`;
+	return `lines ${start}-${end}`;
+}
+
+function parseSedPrintRange(tokens: readonly string[]): string | undefined {
+	for (let i = 0; i < tokens.length; i++) {
+		if (tokens[i] === "-n" && tokens[i + 1]) {
+			const label = formatSedRangeLabel(tokens[i + 1]);
+			if (label) return label;
+		}
+		const direct = formatSedRangeLabel(tokens[i]);
+		if (direct) return direct;
+	}
+	return undefined;
+}
+
+function classifyNlRead(tokens: readonly string[]): BashDisplayInfo | null {
+	const pipeIndex = tokens.indexOf("|");
+	const left = pipeIndex === -1 ? tokens : tokens.slice(0, pipeIndex);
+	if (left[0] !== "nl") return null;
+	const path = singlePathArg(left.slice(1));
+	if (!path) return null;
+	let rangeLabel: string | undefined;
+	if (pipeIndex !== -1) {
+		const right = tokens.slice(pipeIndex + 1);
+		if (right[0] !== "sed" || right.includes("|")) return null;
+		rangeLabel = parseSedPrintRange(right);
+	}
+	return { kind: "read", label: "Read", path, rangeLabel, suppressCollapsedHint: true };
+}
+
+function classifySedRead(tokens: readonly string[]): BashDisplayInfo | null {
+	if (tokens[0] !== "sed") return null;
+	const rangeLabel = parseSedPrintRange(tokens);
+	if (!rangeLabel) return null;
+	const scriptIndex = tokens.findIndex((token) => formatSedRangeLabel(token) !== undefined);
+	const path = singlePathArg(tokens.slice(scriptIndex + 1));
+	if (!path) return null;
+	return { kind: "read", label: "Read", path, rangeLabel, suppressCollapsedHint: true };
+}
+
+function classifyCatRead(tokens: readonly string[]): BashDisplayInfo | null {
+	if (tokens[0] !== "cat") return null;
+	const path = singlePathArg(tokens.slice(1));
+	if (!path) return null;
+	return { kind: "read", label: "Read", path, suppressCollapsedHint: true };
+}
+
+function classifyHeadTailRead(tokens: readonly string[]): BashDisplayInfo | null {
+	const command = tokens[0];
+	if (command !== "head" && command !== "tail") return null;
+	const args = tokens.slice(1);
+	let count: string | undefined;
+	const pathCandidates: string[] = [];
+	for (let i = 0; i < args.length; i++) {
+		const token = args[i];
+		if (token === "--") continue;
+		if (token === "-n" && args[i + 1]) {
+			count = args[i + 1];
+			i++;
+			continue;
+		}
+		const compactCount = token.match(/^-([0-9]+)$/)?.[1];
+		if (compactCount) {
+			count = compactCount;
+			continue;
+		}
+		if (isOptionToken(token)) continue;
+		pathCandidates.push(token);
+	}
+	if (pathCandidates.length !== 1) return null;
+	const amount = count && /^\d+$/.test(count) ? count : "10";
+	const rangeLabel = `${command === "head" ? "first" : "last"} ${amount} lines`;
+	return { kind: "read", label: "Read", path: pathCandidates[0], rangeLabel, suppressCollapsedHint: true };
+}
+
+export function classifyBashCommandForDisplay(command: string): BashDisplayInfo | null {
+	const tokens = tokenizeShellCommand(command.trim());
+	if (!tokens || tokens.length === 0) return null;
+	if (tokens.some(isControlToken)) return null;
+	return classifyNlRead(tokens)
+		?? classifySedRead(tokens)
+		?? classifyCatRead(tokens)
+		?? classifyHeadTailRead(tokens);
+}
+
 function diffCollapsedLimit(): number {
 	const value = readSettings().diffCollapsedLines;
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 24;
@@ -4232,28 +4468,50 @@ export default function (pi: ExtensionAPI) {
 		},
 		renderCall(args, theme, ctx) {
 			syncToolCallStatus(ctx);
-			const summary = stableCallSummary(ctx, "_callSummary", () => summarizeText(args.command, 72));
-			return makeText(ctx.lastComponent, toolHeader("Bash", summary, theme, toolStatusDot(ctx, theme)));
+			const semantic = bashSemanticDisplayEnabled() ? classifyBashCommandForDisplay(args.command ?? "") : null;
+			const summary = stableCallSummary(ctx, "_callSummary", () => {
+				if (!semantic) return summarizeText(args.command, 72);
+				const path = sp(semantic.path);
+				return semantic.rangeLabel ? `${path} ${theme.fg("muted", `(${semantic.rangeLabel})`)}` : path;
+			});
+			return makeText(ctx.lastComponent, toolHeader(semantic?.label ?? "Bash", summary, theme, toolStatusDot(ctx, theme)));
 		},
 		renderResult(result, { expanded, isPartial }, theme, ctx) {
 			const details = result.details as BashToolDetails | undefined;
 			const output = result.content[0]?.type === "text" ? result.content[0].text : "";
 			const nonEmpty = output.split("\n").filter((line) => line.trim().length > 0);
+			const semantic = bashSemanticDisplayEnabled() ? classifyBashCommandForDisplay(ctx.args?.command ?? "") : null;
 			if (isPartial) {
 				setupBlinkTimer(ctx);
-				return makeText(ctx.lastComponent, withBranch(theme.fg("warning", `Running... (${nonEmpty.length} lines)`), theme));
+				const running = semantic?.kind === "read" ? "Reading" : "Running";
+				return makeText(ctx.lastComponent, withBranch(theme.fg("warning", `${running}... (${nonEmpty.length} lines)`), theme));
 			}
 			clearBlinkTimer(ctx);
 			setToolStatus(ctx, ctx.isError ? "error" : "success");
-			const exitMatch = output.match(/exit code: (\d+)/);
+			const exitMatch = output.match(/(?:exit code:|exited with code)\s+(\d+)/i);
 			const exitCode = exitMatch ? Number.parseInt(exitMatch[1], 10) : null;
-			let text = exitCode === null || exitCode === 0 ? theme.fg("success", "Done") : theme.fg("error", `Exit ${exitCode}`);
-			text += theme.fg("muted", ` (${nonEmpty.length} lines)`);
+			const isError = ctx.isError || (exitCode !== null && exitCode !== 0);
+			let text = isError
+				? theme.fg("error", exitCode !== null ? `Exit ${exitCode}` : "Failed")
+				: semantic?.kind === "read"
+					? `${theme.fg("success", "Read")} ${theme.fg("muted", `${nonEmpty.length} line${nonEmpty.length === 1 ? "" : "s"}`)}`
+					: `${theme.fg("success", "Done")}${theme.fg("muted", ` (${nonEmpty.length} lines)`)}`;
 			if (details?.truncation?.truncated) text += theme.fg("warning", " [truncated]");
-			if (!expanded && nonEmpty.length > 0) return makeText(ctx.lastComponent, withBranch(`${text}${theme.fg("muted", " • Ctrl+O to expand")}`, theme));
+
+			const mode = bashOutputMode();
+			if (mode === "summary") return makeText(ctx.lastComponent, withBranch(text, theme));
+			if (mode === "preview") {
+				if (nonEmpty.length === 0) return makeText(ctx.lastComponent, withBranch(text, theme));
+				const preview = buildPreviewText(nonEmpty.map((line) => theme.fg(isError ? "error" : "dim", line)), expanded, theme, bashCollapsedLimit());
+				return makeText(ctx.lastComponent, withBranch(`${text}\n${preview}`, theme));
+			}
+
+			if (!expanded && nonEmpty.length > 0) {
+				const hint = semantic?.suppressCollapsedHint ? "" : theme.fg("muted", " • Ctrl+O to expand");
+				return makeText(ctx.lastComponent, withBranch(`${text}${hint}`, theme));
+			}
 			if (!expanded) return makeText(ctx.lastComponent, withBranch(text, theme));
-			const collapsed = bashCollapsedLimit();
-			text += `\n${buildPreviewText(nonEmpty.map((line) => theme.fg("dim", line)), false, theme, collapsed)}`;
+			text += `\n${buildPreviewText(nonEmpty.map((line) => theme.fg(isError ? "error" : "dim", line)), true, theme, bashCollapsedLimit())}`;
 			return makeText(ctx.lastComponent, withBranch(text, theme));
 		},
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owlburtoe/pi-cc-tools",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Claude Code-style tool rows for pi with Ctrl+O image previews and consistent built-in, MCP, and custom tool rendering",
   "keywords": [
     "pi-package",
@@ -32,6 +32,7 @@
   ],
   "scripts": {
     "bench:tools": "bun scripts/benchmark-tools.ts",
+    "test:bash-display": "bun scripts/test-bash-display.ts",
     "test:message-chrome": "bun scripts/test-message-chrome.ts"
   },
   "dependencies": {