@quandev104/pi-style 0.1.2 → 0.1.3

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

@@ -45,9 +45,9 @@ const allowedPaths = new Set([
 	"editor.frame",
 	"editor.showMetadata",
 	"messages.enabled",
-	"messages.userPrefix",
 	"messages.assistantPrefix",
 	"messages.specialBlocks",
+	"messages.hideThinkingLabel",
 	"tools.enabled",
 	"tools.style",
 	"tools.maxCollapsedLines",
@@ -74,9 +74,9 @@ function validatePathValue(path: string, value: unknown): boolean {
 			"editor.enabled",
 			"editor.showMetadata",
 			"messages.enabled",
-			"messages.userPrefix",
 			"messages.assistantPrefix",
 			"messages.specialBlocks",
+			"messages.hideThinkingLabel",
 			"tools.enabled",
 			"tools.showElapsed",
 			"tools.dimOutput",

package/extension-src/pi-style/app/index.ts

@@ -311,7 +311,6 @@ export function createPiStyleApp(
 					status: operational.installations?.status ?? "unknown",
 					editor: operational.installations?.editor ?? "unknown",
 					startup: operational.installations?.startup ?? "unknown",
-					userMessage: operational.compatibility?.userMessage ?? "unknown",
 					assistantMessage: operational.compatibility?.assistantMessage ?? "unknown",
 					specialBlocks: operational.compatibility?.specialBlocks ?? "unknown",
 					tools: operational.compatibility?.tools ?? "unknown",

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

@@ -4,7 +4,7 @@ export interface TierCAuthorizationInput {
 	readonly certifiedHost: boolean;
 	readonly coreFlag: boolean;
 	readonly surfaceFlag: boolean;
-	readonly surface: "messages" | "tools" | "userMessage" | "assistantMessage" | "specialBlocks";
+	readonly surface: "messages" | "tools" | "assistantMessage" | "specialBlocks";
 	readonly config: NormalizedPiStyleConfig;
 }
 
@@ -12,7 +12,6 @@ export interface TierCAuthorizationInput {
 export function isTierCAuthorized(input: TierCAuthorizationInput): boolean {
 	if (!input.certifiedHost || !input.coreFlag || !input.surfaceFlag || !input.config.enabled) return false;
 	if (input.surface === "tools") return input.config.tools.enabled;
-	if (input.surface === "userMessage") return input.config.messages.enabled && input.config.messages.userPrefix;
 	if (input.surface === "assistantMessage")
 		return input.config.messages.enabled && input.config.messages.assistantPrefix;
 	if (input.surface === "specialBlocks") return input.config.messages.enabled && input.config.messages.specialBlocks;

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

@@ -28,7 +28,7 @@ export const DEFAULT_CONFIG: NormalizedPiStyleConfig = Object.freeze({
 		contextBarWidth: 10,
 	}),
 	editor: Object.freeze({ enabled: true, style: "compact", frame: "auto", showMetadata: false }),
-	messages: Object.freeze({ enabled: true, userPrefix: true, assistantPrefix: true, specialBlocks: true }),
+	messages: Object.freeze({ enabled: true, assistantPrefix: true, specialBlocks: true, hideThinkingLabel: true }),
 	tools: Object.freeze({
 		enabled: true,
 		style: "compact-box",
@@ -159,9 +159,9 @@ export function normalizeConfig(
 		}),
 		messages: Object.freeze({
 			enabled: bool(messages.enabled, defaults.messages.enabled),
-			userPrefix: bool(messages.userPrefix, defaults.messages.userPrefix),
 			assistantPrefix: bool(messages.assistantPrefix, defaults.messages.assistantPrefix),
 			specialBlocks: bool(messages.specialBlocks, defaults.messages.specialBlocks),
+			hideThinkingLabel: bool(messages.hideThinkingLabel, defaults.messages.hideThinkingLabel),
 		}),
 		tools: Object.freeze({
 			enabled: bool(tools.enabled, defaults.tools.enabled),
@@ -213,9 +213,9 @@ const BOOL_PATHS = new Set([
 	"editor.enabled",
 	"editor.showMetadata",
 	"messages.enabled",
-	"messages.userPrefix",
 	"messages.assistantPrefix",
 	"messages.specialBlocks",
+	"messages.hideThinkingLabel",
 	"tools.enabled",
 	"tools.showElapsed",
 	"tools.dimOutput",

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

@@ -32,7 +32,7 @@ export interface PiStyleConfig {
 		contextBarWidth?: number;
 	};
 	editor?: { enabled?: boolean; style?: string; frame?: string; showMetadata?: boolean };
-	messages?: { enabled?: boolean; userPrefix?: boolean; assistantPrefix?: boolean; specialBlocks?: boolean };
+	messages?: { enabled?: boolean; assistantPrefix?: boolean; specialBlocks?: boolean; hideThinkingLabel?: boolean };
 	tools?: {
 		enabled?: boolean;
 		style?: string;
@@ -79,7 +79,7 @@ export interface NormalizedPiStyleConfig {
 		contextBarWidth: number;
 	};
 	readonly editor: { enabled: boolean; style: EditorStyle; frame: EditorFrame; showMetadata: boolean };
-	readonly messages: { enabled: boolean; userPrefix: boolean; assistantPrefix: boolean; specialBlocks: boolean };
+	readonly messages: { enabled: boolean; assistantPrefix: boolean; specialBlocks: boolean; hideThinkingLabel: boolean };
 	readonly tools: {
 		enabled: boolean;
 		style: string;

package/extension-src/pi-style/domain/theme.ts

@@ -107,6 +107,7 @@ const GLYPHS = {
 		powerlineRight: "\uE0B2",
 		powerlineThinLeft: "\uE0B1",
 		powerlineThinRight: "\uE0B3",
+		batchOpen: "\u{F111}",
 	},
 	unicode: {
 		pi: "π",
@@ -118,6 +119,7 @@ const GLYPHS = {
 		powerlineRight: "‹",
 		powerlineThinLeft: "│",
 		powerlineThinRight: "│",
+		batchOpen: "●",
 	},
 	ascii: {
 		pi: "pi",
@@ -129,6 +131,7 @@ const GLYPHS = {
 		powerlineRight: "<",
 		powerlineThinLeft: "|",
 		powerlineThinRight: "|",
+		batchOpen: "v",
 	},
 } as const;
 

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

@@ -174,29 +174,23 @@ function prefixNative(lines: unknown, width: number, prefix: string): string[] |
 }
 
 export type MessageDecorationSnapshot = Readonly<{
-	userPrefix: string;
 	assistantPrefix: string;
-	userEnabled: boolean;
 	assistantEnabled: boolean;
 }>;
 
 export function decorateMessageRender(
-	subtype: "native-user-message" | "native-assistant-message",
 	original: unknown,
 	instance: object,
 	args: unknown[],
 	snapshot: MessageDecorationSnapshot = {
-		userPrefix: "❯ ",
 		assistantPrefix: "│ ",
-		userEnabled: true,
 		assistantEnabled: true,
 	},
 ): unknown {
 	if (typeof original !== "function") return undefined;
 	const width = typeof args[0] === "number" ? args[0] : 0;
-	const enabled = subtype === "native-user-message" ? snapshot.userEnabled : snapshot.assistantEnabled;
-	const prefix = subtype === "native-user-message" ? snapshot.userPrefix : snapshot.assistantPrefix;
-	if (!enabled) return Reflect.apply(original, instance, args);
+	const prefix = snapshot.assistantPrefix;
+	if (!snapshot.assistantEnabled) return Reflect.apply(original, instance, args);
 	if (width <= visibleWidth(prefix)) return Reflect.apply(original, instance, args);
 	// Exactly one native invocation. If the reduced render cannot be certified, the
 	// already-obtained result is the only safe fallback; retrying can mutate state.

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

@@ -13,8 +13,23 @@ import {
 	renderBoxedToolCall,
 	renderBoxedToolResult,
 	replaceTabs,
+	shortenPath,
 } from "../../../shared/box.js";
 import { safeTruncateToWidth, truncateAtCodePointBoundary } from "../../../shared/render-budget.js";
+import {
+	type GrepMatch,
+	groupMatchesByFile,
+	parseFindOutput,
+	parseGrepBareOutput,
+	parseGrepOutput,
+	parseLsLongOutput,
+	parseLsOutput,
+	pluralForm,
+	renderGrepTree,
+	renderOutputTree,
+	SEARCH_ICON,
+	TREE_INDENT,
+} from "./output-tree.js";
 import { getStateElapsedMs, getToolsRenderConfig } from "./session-config.js";
 import { type BoxedToolContext, type BoxedToolDefinition, noteExecutionStart } from "./shared.js";
 
@@ -304,13 +319,382 @@ function createBashResultPreview(
 	};
 }
 
+// ── ls/find/grep/rg command detection ───────────────────────────────────────
+// A bash command whose real command is ls/find/grep/rg (after env assignments,
+// sudo/env/time prefixes, and path stripping), with no shell metacharacters
+// (pipes, redirects, `;`, `&&`, command substitution, subshells, newlines), is
+// rendered as the same boxless output tree as the corresponding native tool.
+// Everything else keeps the boxed command/response shell.
+
+type BashTreeKind = "ls" | "find" | "grep";
+
+interface BashTreeClass {
+	readonly kind: BashTreeKind;
+	readonly pattern?: string;
+	readonly pathLabel?: string;
+	/** grep: exactly one path positional — single-file output (`line: content`)
+	 *  is attributed to it. */
+	readonly singlePath?: string;
+}
+
+const BASH_PREFIX_COMMANDS = new Set(["sudo", "env", "time", "nice", "nohup", "command", "stdbuf", "ionice", "watch"]);
+const BASH_GREP_COMMANDS = new Set(["grep", "egrep", "fgrep", "rg"]);
+// Pipes (`|`), `;`, and `&` are excluded here: the classifier validates them
+// explicitly (allowing `cd X && cmd` chains and a trailing `| head/tail`).
+const BASH_SHELL_META_CHARS = new Set(["<", ">", "(", ")", "`"]);
+
+/** Tokenize a single command line, stripping quotes. Returns null on an
+ *  unterminated quote. `hasMeta` is true if any shell metacharacter appears
+ *  *outside* quotes (so `grep 'a|b' f` stays classifiable). */
+function tokenizeCommandLine(line: string): { tokens: string[]; hasMeta: boolean } | null {
+	const tokens: string[] = [];
+	let current = "";
+	let inToken = false;
+	let quote: string | null = null;
+	let hasMeta = false;
+	for (let i = 0; i < line.length; i++) {
+		const char = line[i] ?? "";
+		if (quote) {
+			if (char === "\\" && quote === '"') {
+				current += line[++i] ?? "";
+				continue;
+			}
+			if (char === quote) {
+				quote = null;
+				continue;
+			}
+			current += char;
+			continue;
+		}
+		if (char === '"' || char === "'") {
+			quote = char;
+			inToken = true;
+			continue;
+		}
+		if (char === " " || char === "\t") {
+			if (inToken) {
+				tokens.push(current);
+				current = "";
+				inToken = false;
+			}
+			continue;
+		}
+		if (BASH_SHELL_META_CHARS.has(char) || (char === "$" && (line[i + 1] ?? "") === "(")) {
+			hasMeta = true;
+			continue;
+		}
+		current += char;
+		inToken = true;
+	}
+	if (quote) return null;
+	if (inToken) tokens.push(current);
+	return { tokens, hasMeta };
+}
+
+/** grep/rg flags that consume a separate value token (`--type ts`). */
+const GREP_VALUE_FLAGS = new Set([
+	"-e",
+	"--regexp",
+	"-g",
+	"--glob",
+	"--type",
+	"-t",
+	"--include",
+	"--exclude",
+	"-C",
+	"-A",
+	"-B",
+	"--context",
+	"--after-context",
+	"--before-context",
+	"-m",
+	"--max-count",
+	"-M",
+	"--max-columns",
+	"--ignore-file",
+]);
+
+/** find flags that consume a separate value token (`-type f`). */
+const FIND_VALUE_FLAGS = new Set([
+	"-type",
+	"-mtime",
+	"-atime",
+	"-ctime",
+	"-size",
+	"-maxdepth",
+	"-mindepth",
+	"-perm",
+	"-group",
+	"-user",
+	"-newer",
+]);
+
+function classifyByArgs(kind: BashTreeKind, args: string[]): BashTreeClass {
+	const positionals: string[] = [];
+	let pattern: string | undefined;
+	for (let i = 0; i < args.length; i++) {
+		const token = args[i] ?? "";
+		if (
+			(kind === "grep" && (token === "-e" || token === "--regexp")) ||
+			(kind === "find" && (token === "-name" || token === "-iname" || token === "-path" || token === "-ipath"))
+		) {
+			pattern = args[++i];
+			continue;
+		}
+		if (kind === "grep" && GREP_VALUE_FLAGS.has(token)) {
+			i++; // skip the flag and its value
+			continue;
+		}
+		if (kind === "find" && FIND_VALUE_FLAGS.has(token)) {
+			i++; // skip the flag and its value
+			continue;
+		}
+		if (token.startsWith("-")) continue;
+		positionals.push(token);
+	}
+	const rawPath = positionals[0] ?? ".";
+	const pathLabel = rawPath === "." ? "current directory" : shortenPath(rawPath);
+	if (kind === "ls") return { kind, pathLabel };
+	if (kind === "find") return { kind, ...(pattern !== undefined ? { pattern } : {}), pathLabel };
+	const grepPattern = pattern ?? positionals[0];
+	const pathArgs = pattern !== undefined ? positionals : positionals.slice(1);
+	const grepPath = pathArgs.join(" ");
+	const grepPathLabel = !grepPath || grepPath === "." ? "current directory" : shortenPath(grepPath);
+	return {
+		kind,
+		...(grepPattern !== undefined ? { pattern: grepPattern } : {}),
+		pathLabel: grepPathLabel,
+		...(pathArgs.length === 1 ? { singlePath: pathArgs[0] ?? "" } : {}),
+	};
+}
+
+/** `head [-n N]` / `tail [-n N]` truncation pipe tail (allowed at the end). */
+function isHeadOrTailTail(tokens: readonly string[]): boolean {
+	if (tokens.length === 0 || (tokens[0] !== "head" && tokens[0] !== "tail")) return false;
+	for (let i = 1; i < tokens.length; i++) {
+		const token = tokens[i] ?? "";
+		if (token === "-n") continue;
+		if (/^\d+$/.test(token)) continue;
+		if (/^-\d+$/.test(token)) continue;
+		return false;
+	}
+	return true;
+}
+
+/** Classify a bash command for tree rendering, or null to keep the boxed shell. */
+export function classifyBashCommand(command: string): BashTreeClass | null {
+	const commandText = String(command ?? "").trim();
+	if (!commandText || commandText.includes("\n")) return null;
+	const tokenized = tokenizeCommandLine(commandText);
+	if (!tokenized || tokenized.hasMeta || tokenized.tokens.length === 0) return null;
+	let tokens = tokenized.tokens;
+
+	// Allow a single trailing truncation pipe: `cmd | head [-n] N` / `| tail …`.
+	const pipes = tokens.flatMap((token, i) => (token === "|" ? [i] : []));
+	if (pipes.length > 0) {
+		if (pipes.length > 1) return null;
+		const last = pipes[0] ?? -1;
+		if (!isHeadOrTailTail(tokens.slice(last + 1))) return null;
+		tokens = tokens.slice(0, last);
+	}
+
+	let index = 0;
+	// Skip leading environment assignments (FOO=bar ...) and prefix commands.
+	while (index < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[index] ?? "")) index++;
+	while (index < tokens.length && BASH_PREFIX_COMMANDS.has(tokens[index] ?? "")) index++;
+	// `cd <dir> &&` / `cd <dir>;` chains: the last directory becomes the default
+	// path when the command itself carries none.
+	let cdDir: string | undefined;
+	while (
+		tokens[index] === "cd" &&
+		index + 2 < tokens.length &&
+		tokens[index + 1] !== undefined &&
+		(tokens[index + 2] === "&&" || tokens[index + 2] === ";")
+	) {
+		cdDir = tokens[index + 1];
+		index += 3;
+	}
+	const rest = tokens.slice(index);
+	if (rest.length === 0 || rest.some((token) => token === "&&" || token === ";" || token === "&")) return null;
+
+	const base = (rest[0] ?? "").split("/").pop() ?? "";
+	let kind: BashTreeKind | null = null;
+	if (base === "ls") kind = "ls";
+	else if (base === "find") kind = "find";
+	else if (BASH_GREP_COMMANDS.has(base)) kind = "grep";
+	if (!kind) return null;
+
+	const cls = classifyByArgs(kind, rest.slice(1));
+	if (cdDir && cls.pathLabel === "current directory") {
+		return {
+			kind,
+			...(cls.pattern !== undefined ? { pattern: cls.pattern } : {}),
+			pathLabel: shortenPath(cdDir),
+			...(cls.singlePath !== undefined ? { singlePath: cls.singlePath } : {}),
+		};
+	}
+	return cls;
+}
+
+function bashTreeHeader(theme: BoxTheme, cls: BashTreeClass, counts?: { files?: number; matches?: number }): string {
+	const label = cls.kind === "find" ? "Glob" : cls.kind === "ls" ? "List" : "Grep";
+	const hasDetail = Boolean(cls.pattern) || Boolean(counts);
+	// ls/find/grep headers carry the magnifying-glass icon in Nerd Font mode.
+	const icon = getToolsRenderConfig().nerdFonts ? `${SEARCH_ICON} ` : "";
+	const prefix = icon + (hasDetail ? `${label}:` : label);
+	const patternPart = cls.pattern ? ` ${theme.fg("text", cls.pattern)}` : "";
+	let middle = "";
+	if (counts) {
+		if (cls.kind === "grep") {
+			const matches = counts.matches ?? 0;
+			const files = counts.files ?? 0;
+			middle = ` ${theme.fg("accent", `${matches} ${pluralForm("match", matches)}`)}${theme.fg("dim", ` · ${files} ${pluralForm("file", files)}`)}`;
+		} else {
+			const files = counts.files ?? 0;
+			middle = ` ${theme.fg("accent", `${files} ${pluralForm("file", files)}`)}`;
+		}
+	}
+	const pathPart =
+		cls.pathLabel && cls.pathLabel !== "current directory" ? theme.fg("dim", ` · in ${cls.pathLabel}`) : "";
+	return `${typeof theme?.bold === "function" ? theme.bold(prefix) : prefix}${patternPart}${middle}${pathPart}`;
+}
+
+/** `ls -l` long-format lines (permissions block) can't be parsed into names
+ *  reliably; fall back to the boxed shell for those. A leading `total N`
+ *  summary line is skipped before the check. */
+function isLongFormatLs(text: string): boolean {
+	const first = text
+		.split("\n")
+		.map((line) => line.trim())
+		.find((line) => line.length > 0 && !/^total\s+\d+$/i.test(line));
+	return Boolean(first) && /^[bcdlsp-][rwxtsST-]{9}[\s@]/.test(first as string);
+}
+
+/** Parsed bash tree output, or null to fall back to the boxed shell
+ *  (long-format ls, unparseable grep). */
+type ParsedBashTree = { entries: string[] } | { matches: GrepMatch[] };
+
+function parseBashTreeOutput(cls: BashTreeClass, output: string): ParsedBashTree | null {
+	if (cls.kind === "ls") {
+		// `ls -l`/`ls -la` long format is parsed into names (with `/` for dirs)
+		// so bash listings render like the List tool tree.
+		if (isLongFormatLs(output)) return { entries: parseLsLongOutput(output) };
+		return { entries: parseLsOutput(output) };
+	}
+	if (cls.kind === "find") return { entries: parseFindOutput(output) };
+	const matches = parseGrepOutput(output);
+	if (matches.length === 0 && output.trim().length > 0) {
+		// Single-file `rg`/`grep` output is `line: content` with no filename:
+		// attribute matches to the command's single path argument.
+		if (cls.singlePath) {
+			const bare = parseGrepBareOutput(output, cls.singlePath);
+			if (bare.length > 0) return { matches: bare };
+		}
+		return null;
+	}
+	return { matches };
+}
+
+interface BashTreeState {
+	readonly cls: BashTreeClass;
+	/** Raw command, so the call panel can render the boxed bash call on fallback. */
+	readonly command: string;
+	/** `parsed` once the result arrives; `fallback` when the boxed shell takes over. */
+	parsed?: ParsedBashTree;
+	fallback?: boolean;
+}
+
+const bashTreeStates = new Map<string, BashTreeState>();
+
+/** Reset all bash tree state (session start/shutdown, new message). */
+export function resetBashTreeRegistry(): void {
+	bashTreeStates.clear();
+}
+
+function renderBashTreeLines(theme: BoxTheme, state: BashTreeState, width: number): string[] {
+	const safeWidth = Math.max(1, width);
+	const cls = state.cls;
+	if (state.parsed && "entries" in state.parsed) {
+		const entries = state.parsed.entries;
+		return renderOutputTree(theme, bashTreeHeader(theme, cls, { files: entries.length }), entries, safeWidth, {
+			moreUnit: "file",
+			indent: TREE_INDENT,
+			withIcons: getToolsRenderConfig().nerdFonts,
+		});
+	}
+	if (state.parsed && "matches" in state.parsed) {
+		const matches = state.parsed.matches;
+		return renderGrepTree(
+			theme,
+			bashTreeHeader(theme, cls, { matches: matches.length, files: groupMatchesByFile(matches).length }),
+			matches,
+			safeWidth,
+			{ indent: TREE_INDENT, withIcons: getToolsRenderConfig().nerdFonts },
+		);
+	}
+	return [safeTruncateToWidth(bashTreeHeader(theme, cls), safeWidth, "…")];
+}
+
+/** Empty result component — the tree lives in the call panel, which re-renders
+ *  with the parsed output once the result arrives. */
+const EMPTY_BASH_TREE_RESULT: Component = {
+	invalidate() {},
+	render() {
+		return [];
+	},
+};
+
+/** Live panel component for a classified bash command: pending header until the
+ *  result arrives, then the parsed output tree. When the result falls back to
+ *  the boxed shell, the call renders the boxed bash call instead, so call and
+ *  result form one complete box and never duplicate. The state reference is
+ *  captured at creation so a registry clear on session reset/resume does not
+ *  blank already-rendered panels. */
+function renderBashTreePanel(theme: BoxTheme, toolCallId: string, context: BoxedToolContext): Component {
+	const state = bashTreeStates.get(toolCallId);
+	return {
+		invalidate() {},
+		render(width: number): string[] {
+			if (!state) return [];
+			if (state.fallback) {
+				return renderBoxedBashCall(
+					theme,
+					state.command.split("\n"),
+					context,
+					bashWidthKey(state.command, context?.args?.timeout),
+				).render(width);
+			}
+			return renderBashTreeLines(theme, state, width);
+		},
+	};
+}
+
 export const bashTool: BoxedToolDefinition = {
 	call(args, theme, context) {
 		noteExecutionStart(context);
+		const cls = classifyBashCommand(String(args?.command ?? ""));
+		if (cls) {
+			bashTreeStates.set(context.toolCallId, { cls, command: String(args?.command ?? "") });
+			return renderBashTreePanel(theme, context.toolCallId, context);
+		}
 		const rawCommand = String(args?.command ?? "...");
 		return renderBoxedBashCall(theme, rawCommand.split("\n"), context, bashWidthKey(rawCommand, args?.timeout));
 	},
 	result(result, options, theme, context) {
+		const cls = classifyBashCommand(String(context?.args?.command ?? ""));
+		if (cls && !context.isError) {
+			const output = stripBashToolNoticeLines(stripAnsi(getTextOutput(result)));
+			const parsed = parseBashTreeOutput(cls, output);
+			const state = bashTreeStates.get(context.toolCallId);
+			if (parsed) {
+				if (state) state.parsed = parsed;
+				else bashTreeStates.set(context.toolCallId, { cls, command: String(context?.args?.command ?? ""), parsed });
+				return EMPTY_BASH_TREE_RESULT;
+			}
+			// Unparseable output (ls -l, raw rg summary): the boxed shell owns the
+			// result; flag the call panel to render nothing so the two don't duplicate.
+			if (state) state.fallback = true;
+		}
 		const raw = getTextOutput(result);
 		const outputColor = context.isError ? "error" : "toolOutput";