pi-compact-tools 0.7.7 → 0.7.8

package/README.md

@@ -30,11 +30,11 @@ Completed `edit` rows show only the lines actually removed (`-`) or added (`+`),
 
 - Compact rendering for `read`, `write`, `edit`, `bash`, `powershell`, `grep`, `find`, and `ls`
 - One continuously glowing working label above the input prompt across thinking and tool execution
-- Semantic built-in progress labels and automatically cleaned custom/MCP tool names without exposing invocation arguments
+- Semantic built-in progress labels and automatically cleaned custom/MCP tool names; collapsed text-search rows include the searched pattern
 - Four-step `Ctrl+T` thinking cycle when provider detail is available: summary, detail, summary, then hidden
 - Millisecond-precision duration and completed output line counts with neutral status text
 - Per-tool hidden or persistent bounded-preview collapsed state with `auto_compact: true` or `false`
-- Primary invocation targets such as paths and patterns stay visible; collapsed shell calls show concise intent summaries
+- Primary invocation targets such as paths and patterns stay visible, including common collapsed shell file operations
 - Click and `Ctrl+O` follow Pi's built-in expansion state while preview rows collapse back to their preview
 - Edit patches display only removed (`-`) and added (`+`) lines, omitting unchanged context
 - Configurable `previewLines` prevents large diffs, HTML, and shell output from flooding the transcript
@@ -125,7 +125,7 @@ one-line summary → summary + │-indented detail → one-line summary → Thin
 
 Standalone bold lines and Markdown headings split one provider thinking run into logical sections. Each section gets its own summary and optional `│`-indented detail. Summary-only views stay uncluttered with no control hint; the control row appears only while provider-supplied detail is visible. When no thinking detail exists, `Ctrl+T` falls back to Pi's normal visible/hidden toggle instead of showing a duplicate detail phase. While thinking streams, a slightly faster highlight sweeps from the Thinking summary color to white across Pi's working label at a steady interval rather than depending on token updates. The transcript summary remains visually stable. The transformation is display-only; complete thinking remains unchanged in the session and model context.
 
-Primary file and search targets stay visible. Collapsed `bash` and `powershell` rows describe intent—such as `Run tests`, `Check repository status`, or `Search text`—without printing arguments; expanding the row reveals the exact command. After every supported tool completes, the status reports the expanded result size as `Done in …s (N lines)` instead of repeating options such as context and limit. Counts use the returned text for reads, searches, listings, and shell commands, written content for `write`, and only the displayed `-`/`+` lines for `edit`. The count is computed once after completion and cached with the row, so streaming and repeated expansion do not add ongoing work. Large payloads represented as results follow the result toggle.
+Primary file and search targets stay visible. Collapsed `bash` and `powershell` rows describe intent—such as `Run tests` or `Check repository status`. Text searches retain their primary pattern (for example, `Search text "TODO|FIXME"`), and common file commands retain their operands (for example, `Run rm "build"` or `Find files "*.test.ts" in "src"`). Expanding the row reveals the exact command. After every supported tool completes, the status reports the expanded result size as `Done in …s (N lines)` instead of repeating options such as context and limit. Counts use the returned text for reads, searches, listings, and shell commands, written content for `write`, and only the displayed `-`/`+` lines for `edit`. The count is computed once after completion and cached with the row, so streaming and repeated expansion do not add ongoing work. Large payloads represented as results follow the result toggle.
 
 A mouse click toggles one row using Pi's native result state. `Ctrl+O` remains owned by Pi and expands or collapses all tool rows consistently, including tools not rendered by this extension. A row with `auto_compact: false` cycles predictably between its bounded preview and the complete result, so repeated clicks never remove the row and fall through to a neighboring Thinking block. The extension does not intercept the global keybinding.
 

package/extensions/compact-tools-invocation.ts

@@ -77,18 +77,192 @@ function shellSegments(command: string): string[] {
 	return segments;
 }
 
-function unquote(value: string): string {
-	return value.replace(/^["']|["']$/gu, "");
+function shellWords(command: string, powershell = false): string[] {
+	const words: string[] = [];
+	let current = "";
+	let quote: "'" | '"' | undefined;
+	const input = command.trim();
+	for (let index = 0; index < input.length; index++) {
+		const character = input[index]!;
+		if (powershell && character === "`" && quote !== "'") {
+			const next = input[index + 1];
+			if (next !== undefined) {
+				current += next;
+				index++;
+			}
+			continue;
+		}
+		if (!powershell && character === "\\" && quote !== "'") {
+			const next = input[index + 1];
+			if (next === undefined) {
+				current += "\\";
+				continue;
+			}
+			// In double quotes, Bash preserves backslashes before ordinary characters.
+			if (quote === '"' && !['$', '`', '"', "\\", "\n"].includes(next)) {
+				current += "\\";
+				continue;
+			}
+			current += next;
+			index++;
+			continue;
+		}
+		if (quote) {
+			if (character === quote) quote = undefined;
+			else current += character;
+			continue;
+		}
+		if (character === "'" || character === '"') {
+			quote = character;
+			continue;
+		}
+		if (/\s/u.test(character)) {
+			if (current) words.push(current);
+			current = "";
+			continue;
+		}
+		current += character;
+	}
+	if (current) words.push(current);
+	return words;
+}
+
+const SEARCH_OPTIONS_WITH_VALUES = new Set([
+	"-a", "--after-context", "-b", "--before-context", "-c", "--context", "--context-separator",
+	"-d", "--max-depth", "--dfa-size-limit", "-f", "--file", "-g", "--glob", "--iglob",
+	"-m", "--max-count", "--max-columns", "--path-separator", "--pre", "--pre-glob",
+	"--regex-size-limit", "--replace", "--sort", "--sortr", "-t", "--type", "--type-not",
+	"--encoding", "--engine", "--field-context-separator", "--field-match-separator", "--hostname-bin",
+	"--binary-files", "--exclude", "--exclude-from", "--exclude-dir", "--include", "--label",
+]);
+
+function searchPattern(executable: string, words: string[]): string | undefined {
+	const args = words.slice(1);
+	for (let index = 0; index < args.length; index++) {
+		const argument = args[index] ?? "";
+		const lower = argument.toLowerCase();
+		if (executable === "select-string") {
+			if (lower === "-pattern") return args[index + 1];
+			if (lower.startsWith("-pattern:")) return argument.slice(argument.indexOf(":") + 1);
+			if (!argument.startsWith("-")) return argument;
+			continue;
+		}
+		if (lower === "-e" || lower === "--regexp") return args[index + 1];
+		if (lower.startsWith("--regexp=")) return argument.slice(argument.indexOf("=") + 1);
+		if (/^-e.+/u.test(argument)) return argument.slice(2);
+		if (argument === "--") return args[index + 1];
+		const optionName = lower.split("=", 1)[0] ?? lower;
+		if (SEARCH_OPTIONS_WITH_VALUES.has(optionName) && !argument.includes("=")) {
+			index++;
+			continue;
+		}
+		if (argument.startsWith("-")) continue;
+		return argument;
+	}
+	return undefined;
+}
+
+function summarizeTextSearch(executable: string, words: string[]): string {
+	const pattern = searchPattern(executable, words);
+	return pattern === undefined ? "Search text" : `Search text ${JSON.stringify(pattern)}`;
+}
+
+function formatTargets(targets: string[]): string {
+	const visible = targets.slice(0, 2).map((target) => JSON.stringify(target)).join(", ");
+	const remaining = targets.length - 2;
+	return remaining > 0 ? `${visible} + ${remaining} more` : visible;
+}
+
+function plainOperands(words: string[]): string[] {
+	const separator = words.indexOf("--");
+	if (separator >= 0) return words.slice(separator + 1);
+	return words.slice(1).filter((word) => !word.startsWith("-"));
+}
+
+function optionValue(words: string[], names: string[]): string | undefined {
+	for (let index = 1; index < words.length; index++) {
+		const word = words[index] ?? "";
+		const lower = word.toLowerCase();
+		if (names.includes(lower)) return words[index + 1];
+		const prefix = names.find((name) => lower.startsWith(`${name}=`) || lower.startsWith(`${name}:`));
+		if (prefix) return word.slice(prefix.length + 1);
+	}
+	return undefined;
+}
+
+const FD_OPTIONS_WITH_VALUES = new Set([
+	"-d", "--max-depth", "-e", "--extension", "-E", "--exclude", "-t", "--type",
+	"-x", "--exec", "-X", "--exec-batch", "-j", "--threads", "--base-directory",
+	"--changed-before", "--changed-within", "--format", "--glob", "--path-separator",
+	"--search-path", "--size", "--strip-cwd-prefix",
+].map((option) => option.toLowerCase()));
+
+function fdOperands(words: string[]): string[] {
+	const operands: string[] = [];
+	for (let index = 1; index < words.length; index++) {
+		const word = words[index] ?? "";
+		if (word === "--") return [...operands, ...words.slice(index + 1)];
+		const optionName = word.toLowerCase().split("=", 1)[0] ?? word.toLowerCase();
+		if (FD_OPTIONS_WITH_VALUES.has(optionName) && !word.includes("=")) {
+			index++;
+			continue;
+		}
+		if (!word.startsWith("-")) operands.push(word);
+	}
+	return operands;
+}
+
+function summarizeFileDiscovery(executable: string, words: string[]): string {
+	if (executable === "find") {
+		const paths: string[] = [];
+		for (let index = 1; index < words.length; index++) {
+			const word = words[index] ?? "";
+			if (word.startsWith("-") || word === "!" || word === "(") break;
+			paths.push(word);
+		}
+		const pattern = optionValue(words, ["-name", "-iname", "-path", "-ipath", "-regex"]);
+		const location = formatTargets(paths.length > 0 ? paths : ["."]);
+		return pattern ? `Find files ${JSON.stringify(pattern)} in ${location}` : `Find files in ${location}`;
+	}
+	if (executable === "fd") {
+		const operands = fdOperands(words);
+		const pattern = operands[0];
+		const locations = operands.slice(1);
+		if (!pattern) return "Find files";
+		return locations.length > 0
+			? `Find files ${JSON.stringify(pattern)} in ${formatTargets(locations)}`
+			: `Find files ${JSON.stringify(pattern)}`;
+	}
+	const explicitPath = optionValue(words, ["-path", "-literalpath"]);
+	const targets = explicitPath ? [explicitPath] : plainOperands(words);
+	return targets.length > 0 ? `List files ${formatTargets(targets)}` : "List files";
+}
+
+function summarizeFileOperation(executable: string, words: string[]): string | undefined {
+	const targets = plainOperands(words);
+	if (targets.length === 0) return undefined;
+	if (["rm", "del", "erase", "remove-item"].includes(executable)) return `Run ${executable} ${formatTargets(targets)}`;
+	if (["cat", "type", "get-content"].includes(executable)) return `Read file ${formatTargets(targets)}`;
+	if (["mkdir", "md", "new-item"].includes(executable)) return `Create ${formatTargets(targets)}`;
+	if (["rmdir", "rd"].includes(executable)) return `Remove directory ${formatTargets(targets)}`;
+	if (["touch"].includes(executable)) return `Touch ${formatTargets(targets)}`;
+	if (["cp", "copy", "copy-item"].includes(executable) && targets.length >= 2) {
+		return `Copy ${JSON.stringify(targets[0])} to ${JSON.stringify(targets.at(-1))}`;
+	}
+	if (["mv", "move", "move-item", "ren", "rename-item"].includes(executable) && targets.length >= 2) {
+		return `Move ${JSON.stringify(targets[0])} to ${JSON.stringify(targets.at(-1))}`;
+	}
+	return undefined;
 }
 
-/** A calm collapsed label that describes intent without exposing command arguments. */
+/** A calm collapsed label that describes intent while retaining primary command targets. */
 export function summarizeShellCommand(name: string, command: string): string {
 	const allSegments = shellSegments(normalizeLineEndings(command));
 	const segments = allSegments.filter((segment) => !/^\s*(?:cd|pushd|popd)\b/iu.test(segment));
 	const primary = segments[0] ?? allSegments[0] ?? "";
 	if (!primary) return name === "powershell" ? "Prepare PowerShell command" : "Prepare shell command";
 
-	const words = primary.trim().split(/\s+/u).map(unquote);
+	const words = shellWords(primary, name === "powershell");
 	while (words.length > 0) {
 		if (/^[A-Za-z_][A-Za-z\d_]*=.*/u.test(words[0] ?? "")
 			|| ["command", "env", "sudo", "time"].includes((words[0] ?? "").toLowerCase())) {
@@ -117,11 +291,11 @@ export function summarizeShellCommand(name: string, command: string): string {
 	} else if (executable === "git" && ["fetch", "pull", "push", "clone"].includes(action)) {
 		summary = `${action[0]!.toUpperCase()}${action.slice(1)} repository`;
 	} else if (["rg", "grep", "select-string"].includes(executable)) {
-		summary = "Search text";
+		summary = summarizeTextSearch(executable, words);
 	} else if (["find", "fd", "get-childitem", "ls", "dir"].includes(executable)) {
-		summary = executable === "ls" || executable === "dir" || executable === "get-childitem" ? "List files" : "Find files";
-	} else if (["cat", "type", "get-content"].includes(executable)) {
-		summary = "Read file content";
+		summary = summarizeFileDiscovery(executable, words);
+	} else if (summarizeFileOperation(executable, words)) {
+		summary = summarizeFileOperation(executable, words)!;
 	} else if (["tsc", "mypy", "pyright"].includes(executable)) {
 		summary = "Check types";
 	} else if (["jest", "vitest", "pytest", "invoke-pester"].includes(executable)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-compact-tools",
-  "version": "0.7.7",
+  "version": "0.7.8",
   "description": "Compact, expandable UI for pi's built-in tools, bundled with a polished GitHub Dark theme.",
   "type": "module",
   "license": "MIT",