pi-claude-code-ui 1.0.91 → 1.0.93

package/CHANGELOG.md

@@ -3,6 +3,29 @@
 > [!IMPORTANT]
 > **1.0.69 — package rename (permanent).** Canonical npm name is now [`pi-claude-code-ui`](https://www.npmjs.com/package/pi-claude-code-ui). `pi-claude-style-tools` is legacy and will not receive further releases. Install with `pi install npm:pi-claude-code-ui` or `npm i pi-claude-code-ui`.
 
+## 1.0.93 — 2026-10-25
+
+### Added
+
+- **Grouped tool calls read as one sentence** - a run of calls collapses to `Read 2 files, ran 1 shell command` instead of a header plus a row per call. While they run it says `Reading 2 files, running 1 shell command… · 3s` with the call in progress underneath; `Ctrl+O` still shows every call. Inspired by [pi-polish](https://github.com/Pringled/pi-extensions/tree/main/packages/pi-polish).
+- **The working line says what is happening** - while a tool runs it reads `Running npm test…`, `Reading stats.py…`, `Searching for TODO…` or `Waiting for agent: …`; the playful verbs remain while the model thinks.
+- **`❯` prompt markers** - past prompts are one line in the theme's prompt color starting with `❯`, instead of a box labelled `User`, and the input line gets the same `❯`.
+- **Shell file edits are drawn as edits** - bash calls that only change files (`sed -i`, `perl -pi`, `cat > file <<EOF`, `tee`, `echo … > file`) show as `Edit (sed) stats.py` or `Create (heredoc) notes.md` with a diff, taken from the file before and after the command. The command and what the model sees are unchanged; the diff is kept with the row, so it shows again after a resume. These rows are never folded into a group.
+- **[pi-subagents](https://github.com/tintinweb/pi-subagents) support** - `Agent` rows show the agent type, what a running agent is doing, and its tool uses, tokens and time when done. Completion notices and the live "Agents" widget use the same green dots, connectors and indentation as tool rows (they used pink markers, `└─` arms, and a column of their own).
+
+### Fixed
+
+- **Edit rows were indented one column further than every other row** on pi 1.4, along with their diff.
+- **Tools without a summary of their own repeated their name** (`Ctx Reduce Ctx Reduce`); they now show their main argument.
+- **Kotlin script files (`.kts`) were not syntax-highlighted** in diffs.
+
+## 1.0.92 — 2026-10-24
+
+### Changed
+
+- **Terminal colors are on by default** - on pi 1.4 or newer, pi now follows the terminal's palette (Ghostty, Rex, ...) without `/cc-theme terminal on`. The first start switches to pi's `system` theme, saves the theme you had as `terminalThemePrevious`, and says so; `/cc-theme terminal off` (or `"terminalTheme": false`) restores that theme and keeps it. `pi --use-theme <name>` still wins for that run, and older pi versions are left alone.
+- **Branch connectors have one rule and no settings** - `├ └ │` are always a faint mark at a fixed 2:1 contrast against the terminal background, which keeps them visible on dark, light, and tinted themes. The `/cc-tools branch` command and the `toolBranchColorMode` / `toolBranchRgbGray` settings are removed; existing values are ignored. On pi before 1.4 the contrast is taken against black or white (rgb 72 on dark themes, as before).
+
 ## 1.0.91 — 2026-10-24
 
 ### Added

package/README.md

@@ -25,13 +25,17 @@ Claude Code inspired tool rendering for Pi — Shiki-powered diffs, status dots,
 - **MCP-aware rendering** with hidden, summary, and preview modes
 - **Configurable output modes** for read, search, bash, and MCP results
 - **Live running previews** that show a few output lines for active tool calls (latest lines for bash), persisting until the next tool/text activity
-- **Subagent completion notifications** restyled to match the same Claude-style tool rows
+- **[pi-subagents](https://github.com/tintinweb/pi-subagents) support** — `Agent` rows show what a running agent is doing and its tool uses, tokens and time; completion notices and the live "Agents" widget use the same dots, connectors and indentation as tool rows
+- **Shell file edits drawn as edits** — a bash call that only changes files (`sed -i`, `perl -pi`, a heredoc, `echo … > file`) shows as `Edit (sed) path` or `Create (heredoc) path` with a diff of what changed. The command runs unchanged and the model sees the same output; only the row is drawn differently
 - **RTK rewrite integration** that folds rewrite notices into the bash tool row with a muted `(RTK)` badge and expanded-only rewrite details
 - **Transparent tool backgrounds** in `transparent` or `border` mode
-- **Terminal colors** — `/cc-theme terminal on` makes pi's theme follow the terminal's own palette (Ghostty, Rex, kitty, WezTerm, …), including switches between two dark or two light themes
-- **Theme-adaptive palette** — borders, branch connectors, dim text, spinner accent, diff highlighting, and diff backgrounds automatically follow the active pi theme (set `themeAdaptive: false` to keep the fixed Claude-style palette)
+- **Terminal colors** (default, pi 1.4+) — pi's theme follows the terminal's own palette (Ghostty, Rex, kitty, WezTerm, …), including switches between two dark or two light themes; `/cc-theme terminal off` keeps a theme of your choice
+- **Theme-adaptive palette** — dim text, spinner accent, diff highlighting, and diff backgrounds automatically follow the active pi theme (set `themeAdaptive: false` to keep the fixed Claude-style palette)
+- **Faint branch connectors** — `├ └ │` keep the same faint contrast on every terminal background, dark or light
 - **Transparent edit/write diffs** tinted with the theme's own diff colors
-- **Grouped consecutive tool calls** with single-row summaries for repeated targets and per-tool glance rows for mixed work (set `groupToolCalls: false` to disable)
+- **Grouped consecutive tool calls** read as one sentence: `Read 2 files, ran 1 shell command`, or while they run `Reading 2 files, running 1 shell command… · 3s` with the call in progress underneath. `Ctrl+O` shows every call (set `groupToolCalls: false` to disable)
+- **Activity status line** — while a tool runs, the working line says what it is doing (`Running npm test…`, `Reading stats.py…`, `Searching for TODO…`); the playful verbs stay for the time the model is thinking
+- **`❯` prompt markers** — past prompts are one highlighted line starting with `❯`, and the input line gets the same marker, in the column where tool rows put their `●`
 - **Extra detail toggle** with `Ctrl+Shift+O`, increasing expanded preview caps without making the default view heavy
 - **Global border patch** for all tool rows, including unknown/custom tools
 
@@ -59,7 +63,7 @@ Set in `.pi/settings.json` or the active Pi agent settings file (`$PI_CODING_AGE
   "diffCollapsedLines": 24,
   "diffLayout": "auto",
   "themeAdaptive": true,
-  "terminalTheme": false
+  "terminalTheme": true
 }
 ```
 
@@ -71,8 +75,6 @@ When `themeAdaptive` is `true` (default), the following colors are derived from
 
 | Element | Derived from |
 |---------|--------------|
-| Branch connectors (`├`, `└`, `│`) | terminal background blended toward its text color to a 2:1 contrast (rgb 72 on a near-black terminal); `/cc-tools branch theme` uses `dim` → `muted` → `borderMuted` instead, `/cc-tools branch <0-255>` an exact gray |
-| User box, tool rules, code fences, thinking rule | the same blend at a 5.1:1 contrast (rgb ~136 on a near-black terminal) |
 | "✻ Turn took Ns" line (final message only, with session total + turn count) | `muted` |
 | Expanded thinking-block text and `∴` marker | `muted` |
 | Diff add/remove accents | `toolDiffAdded` / `toolDiffRemoved` |
@@ -82,7 +84,9 @@ When `themeAdaptive` is `true` (default), the following colors are derived from
 | Spinner verb text (`Working…`) | `borderAccent` (fallback: `accent`) |
 | Spinner status text | `muted` |
 
-These need pi 1.4 or newer, which exposes the theme's concrete colors. On older pi versions branch connectors stay rgb 72, diffs use `github-dark` / `github-light`, and diff tints are mixed against `toolSuccessBg`.
+These need pi 1.4 or newer, which exposes the theme's concrete colors. On older pi versions diffs use `github-dark` / `github-light`, and diff tints are mixed against `toolSuccessBg`.
+
+Branch connectors (`├`, `└`, `│`) and outlines (user box, tool rules, code fences, thinking rule) are neutral marks with nothing to configure. They blend the terminal's background toward its text color until they reach a fixed contrast: 2:1 for connectors (rgb 72 on a near-black terminal) and 5.1:1 for outlines (rgb ~136), so connectors stay faint but visible on dark, light, and tinted themes alike. On pi versions before 1.4, which don't report the terminal's colors, the same contrasts are taken against black or white.
 
 User-supplied `diffTheme` presets and `diffColors` overrides always win over theme-derived defaults. File-type icons (e.g. `ts`, `py`, `rs`) keep their language-identity colors and are not theme-derived.
 
@@ -92,13 +96,13 @@ On `/resume`, `/new`, or `/fork`, tool chrome is rebound from the **current** pi
 
 ### Terminal colors (Ghostty, Rex, …)
 
-`/cc-theme terminal on` switches pi to its built-in `system` theme, which builds every pi color from the palette the terminal reports, and keeps it there on every start. The theme you had before is saved as `terminalThemePrevious`; `/cc-theme terminal off` restores it.
+On by default: at startup the extension switches pi to its built-in `system` theme, which builds every pi color from the palette the terminal reports, and keeps it there on every start. The theme you had before is saved as `terminalThemePrevious`; `/cc-theme terminal off` (or `"terminalTheme": false`) restores it and keeps it. `pi --use-theme <name>` still picks the theme for that run, and on pi versions without the `system` theme (before 1.4) nothing changes.
 
 Pi already rebuilds the `system` theme when the terminal switches between light and dark. Terminals send no notification when you switch between two themes of the same kind, for example from one dark Rex theme to another, so this extension also asks the terminal for its color scheme whenever the terminal window regains focus (you went to the terminal's settings and came back). Pi then re-reads the palette and repaints only if the colors changed. The query is answered by Ghostty, Rex, and other terminals that support color scheme reports; in regular (non-fullscreen) mode the extension turns on focus reporting itself and keeps the focus events out of the editor.
 
 ```text
 /cc-theme terminal on       # follow the terminal's colors
-/cc-theme terminal off      # go back to the previous theme
+/cc-theme terminal off      # go back to the previous theme and keep it
 /cc-theme terminal status   # show the current state
 ```
 
@@ -116,7 +120,7 @@ The selection is persisted to the active Pi agent settings file and applied to t
 
 #### Repaint the spinner with `/cc-spinner`
 
-The spinner glyph itself is still colored by pi's loader using `accent`, while the verb text (e.g. `Cooking…`) follows `borderAccent` by default so it stays lively without being the exact same color as the glyph. The status suffix (e.g. `(thinking · ↓ 10 tokens · 2s)`) follows `muted`. Use `/cc-spinner` to bind either text element to any other theme color key:
+While a tool runs, the verb names what it is doing (`Running npm test…`); otherwise it is a playful verb. The spinner glyph itself is still colored by pi's loader using `accent`, while the verb text (e.g. `Cooking…`) follows `borderAccent` by default so it stays lively without being the exact same color as the glyph. The status suffix (e.g. `(thinking · ↓ 10 tokens · 2s)`) follows `muted`. Use `/cc-spinner` to bind either text element to any other theme color key:
 
 ```text
 /cc-spinner preview          # list every common theme key with a colored sample
@@ -189,3 +193,4 @@ This project builds upon and was inspired by the excellent work of:
 - **[@heyhuynhgiabuu/pi-pretty](https://github.com/buddingnewinsights/pi-pretty)** by [huynhgiabuu](https://github.com/buddingnewinsights) — Pretty terminal output with syntax-highlighted file reads, colored bash output, and tree-view directory listings
 - **[@heyhuynhgiabuu/pi-diff](https://github.com/buddingnewinsights/pi-diff)** by [huynhgiabuu](https://github.com/buddingnewinsights) — Shiki-powered terminal diff renderer with word-level diffs in split and unified views
 - **[pi-tool-display](https://github.com/MasuRii/pi-tool-display)** by [MasuRii](https://github.com/MasuRii) — Compact tool call rendering, diff visualization, and output truncation
+- **[pi-polish](https://github.com/Pringled/pi-extensions/tree/main/packages/pi-polish)** by [Thomas van Dongen](https://github.com/Pringled) — Claude Code-style output for Pi; the one-sentence tool groups, the activity status line, and the `❯` prompt markers follow its design

package/config/config.example.json

@@ -17,6 +17,6 @@
   "diffCollapsedLines": 24,
   "showTruncationHints": false,
   "themeAdaptive": true,
-  "terminalTheme": false,
+  "terminalTheme": true,
   "diffColors": {}
 }

package/extensions/bash-file-edit.ts

@@ -0,0 +1,301 @@
+// Recognize shell commands that only change files (sed -i, perl -pi, heredoc and echo
+// redirects), so their bash rows can be drawn like edit/write rows with a diff.
+// Purely a rendering aid: the command runs unchanged, and anything this parser is
+// unsure about stays an ordinary bash row.
+
+export type BashFileEditKind = "edit" | "write";
+
+export interface BashFileEdit {
+	/** "edit" for in-place changes and appends, "write" for files written whole. */
+	kind: BashFileEditKind;
+	/** How the file was changed, shown next to the label: "sed", "perl", "heredoc", "echo", "printf", "append". */
+	via: string;
+	/** Target paths as written in the command. */
+	paths: string[];
+	/** Directory from a leading `cd DIR &&`, as written. */
+	cd?: string;
+	/** Content written by a heredoc or echo/printf redirect, when known. */
+	content?: string;
+}
+
+type Token = { type: "word"; value: string } | { type: "op"; value: string };
+
+const MAX_COMMAND_LENGTH = 200_000;
+
+/** Split a heredoc body off the command: `cat > f <<'EOF'\nbody\nEOF` → head + body. */
+function splitHeredoc(command: string): { head: string; body?: string; rest: string; expands?: boolean } | undefined {
+	const match = /<<-?[ \t]*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\1/.exec(command);
+	if (!match) return { head: command, rest: "" };
+	const newline = command.indexOf("\n", match.index);
+	if (newline === -1) return undefined;
+	const delimiter = match[2];
+	const stripTabs = command.slice(match.index, match.index + 3) === "<<-";
+	const lines = command.slice(newline + 1).split("\n");
+	const end = lines.findIndex((line) => (stripTabs ? line.replace(/^\t+/, "") : line) === delimiter);
+	if (end === -1) return undefined;
+	const head = command.slice(0, match.index) + command.slice(match.index + match[0].length, newline);
+	const body = lines.slice(0, end).map((line) => (stripTabs ? line.replace(/^\t+/, "") : line)).join("\n");
+	// An unquoted delimiter lets the shell expand $VAR and `cmd` in the body.
+	const expands = !match[1] && /[$`\\]/.test(body);
+	return { head: `${head} <<HEREDOC`, body: `${body}\n`, rest: lines.slice(end + 1).join("\n"), expands };
+}
+
+/** Minimal POSIX-ish tokenizer: quotes, backslash escapes, and the operators we care about. */
+function tokenize(text: string): Token[] | undefined {
+	const tokens: Token[] = [];
+	let i = 0;
+	let word: string | null = null;
+	const flush = () => {
+		if (word !== null) tokens.push({ type: "word", value: word });
+		word = null;
+	};
+	while (i < text.length) {
+		const c = text[i];
+		if (c === " " || c === "\t" || c === "\n") {
+			flush();
+			if (c === "\n") tokens.push({ type: "op", value: ";" });
+			i++;
+			continue;
+		}
+		if (c === "'") {
+			const end = text.indexOf("'", i + 1);
+			if (end === -1) return undefined;
+			word = (word ?? "") + text.slice(i + 1, end);
+			i = end + 1;
+			continue;
+		}
+		if (c === '"') {
+			let j = i + 1;
+			let value = "";
+			while (j < text.length && text[j] !== '"') {
+				if (text[j] === "\\" && j + 1 < text.length && '"\\$`'.includes(text[j + 1])) {
+					value += text[j + 1];
+					j += 2;
+					continue;
+				}
+				// Expansions inside double quotes make the value unknowable here.
+				if (text[j] === "$" || text[j] === "`") return undefined;
+				value += text[j++];
+			}
+			if (j >= text.length) return undefined;
+			word = (word ?? "") + value;
+			i = j + 1;
+			continue;
+		}
+		if (c === "\\" && i + 1 < text.length) {
+			word = (word ?? "") + text[i + 1];
+			i += 2;
+			continue;
+		}
+		const two = text.slice(i, i + 2);
+		if (two === "&&" || two === "||" || two === ">>" || two === "<<") {
+			flush();
+			tokens.push({ type: "op", value: two });
+			i += 2;
+			continue;
+		}
+		if (c === ";" || c === "|" || c === ">" || c === "<" || c === "&" || c === "(" || c === ")") {
+			flush();
+			tokens.push({ type: "op", value: c });
+			i++;
+			continue;
+		}
+		if (c === "$" || c === "`") return undefined;
+		word = (word ?? "") + c;
+		i++;
+	}
+	flush();
+	return tokens;
+}
+
+/** Split tokens into simple commands joined by && or ;. Pipes, ||, &, subshells: unsupported. */
+function splitCommands(tokens: Token[]): Token[][] | undefined {
+	const commands: Token[][] = [[]];
+	for (const token of tokens) {
+		if (token.type === "op" && (token.value === "&&" || token.value === ";")) {
+			if (commands[commands.length - 1].length > 0) commands.push([]);
+			continue;
+		}
+		if (token.type === "op" && ["||", "|", "&", "(", ")"].includes(token.value)) return undefined;
+		commands[commands.length - 1].push(token);
+	}
+	return commands.filter((command) => command.length > 0);
+}
+
+const words = (command: Token[]): string[] | undefined =>
+	command.every((token) => token.type === "word") ? command.map((token) => token.value) : undefined;
+
+function isPlainPath(path: string): boolean {
+	return path.length > 0 && path !== "-" && !/[*?[\]{}]/.test(path) && !path.startsWith("/dev/");
+}
+
+/** `sed -i[SUFFIX] [-e SCRIPT]... [SCRIPT] FILE...` (GNU and BSD forms). */
+function parseSed(args: string[]): string[] | undefined {
+	let inPlace = false;
+	let haveScript = false;
+	const files: string[] = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "-i" || arg === "--in-place") {
+			inPlace = true;
+			// BSD sed: `-i ''` or `-i .bak` takes the suffix as its own argument.
+			if (i + 1 < args.length && (args[i + 1] === "" || /^\.[\w.-]*$/.test(args[i + 1]))) i++;
+			continue;
+		}
+		if (/^-i\S+$/.test(arg) || arg.startsWith("--in-place=")) {
+			inPlace = true;
+			continue;
+		}
+		if (arg === "-e" || arg === "--expression" || arg === "-f" || arg === "--file") {
+			haveScript = true;
+			i++;
+			continue;
+		}
+		if (/^-[EnrsuzE]+$/.test(arg) || arg === "--regexp-extended" || arg === "--posix") continue;
+		if (arg.startsWith("-")) return undefined;
+		if (!haveScript) {
+			haveScript = true;
+			continue;
+		}
+		files.push(arg);
+	}
+	return inPlace && haveScript && files.length > 0 && files.every(isPlainPath) ? files : undefined;
+}
+
+/** `perl -pi[SUFFIX] -e SCRIPT FILE...` and combined flags such as `-0pi -e`. */
+function parsePerl(args: string[]): string[] | undefined {
+	let inPlace = false;
+	let haveScript = false;
+	const files: string[] = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "-e" || arg === "-E") {
+			haveScript = true;
+			i++;
+			continue;
+		}
+		if (/^-[\w.]+$/.test(arg)) {
+			const flags = arg.slice(1);
+			// Everything after `i` is the backup suffix (`-pi.bak`).
+			if (flags.includes("i")) {
+				inPlace = true;
+				continue;
+			}
+			// `-pe SCRIPT`, `-0pe SCRIPT`.
+			if (/[eE]$/.test(flags)) {
+				haveScript = true;
+				i++;
+			}
+			continue;
+		}
+		if (arg.startsWith("-")) return undefined;
+		if (!haveScript) {
+			haveScript = true;
+			continue;
+		}
+		files.push(arg);
+	}
+	return inPlace && haveScript && files.length > 0 && files.every(isPlainPath) ? files : undefined;
+}
+
+/** `cat > FILE <<EOF`, `cat <<EOF >> FILE`, `tee [-a] FILE <<EOF`, `echo TEXT > FILE`, `printf FMT > FILE`. */
+function parseWrite(command: Token[], heredocBody: string | undefined): Omit<BashFileEdit, "cd"> | undefined {
+	const name = command[0]?.type === "word" ? command[0].value : "";
+	const plain: string[] = [];
+	let target: string | undefined;
+	let append = false;
+	let heredoc = false;
+	for (let i = 1; i < command.length; i++) {
+		const token = command[i];
+		if (token.type === "op" && (token.value === ">" || token.value === ">>")) {
+			const next = command[i + 1];
+			if (target !== undefined || next?.type !== "word") return undefined;
+			target = next.value;
+			append = token.value === ">>";
+			i++;
+			continue;
+		}
+		if (token.type === "op" && token.value === "<<") {
+			const next = command[i + 1];
+			if (next?.type !== "word" || next.value !== "HEREDOC") return undefined;
+			heredoc = true;
+			i++;
+			continue;
+		}
+		if (token.type === "op") return undefined;
+		plain.push(token.value);
+	}
+	if (name === "cat" && heredoc && plain.length === 0 && target && isPlainPath(target)) {
+		return { kind: append ? "edit" : "write", via: append ? "append" : "heredoc", paths: [target], content: heredocBody };
+	}
+	if (name === "tee" && heredoc && !target) {
+		const teeAppend = plain[0] === "-a" || plain[0] === "--append";
+		const files = teeAppend ? plain.slice(1) : plain;
+		if (files.length !== 1 || !isPlainPath(files[0]) || files[0].startsWith("-")) return undefined;
+		return { kind: teeAppend ? "edit" : "write", via: teeAppend ? "append" : "heredoc", paths: files, content: heredocBody };
+	}
+	if ((name === "echo" || name === "printf") && !heredoc && target && isPlainPath(target)) {
+		let content: string | undefined;
+		if (name === "echo") {
+			const noNewline = plain[0] === "-n";
+			const parts = plain.filter((part, index) => !(index === 0 && (part === "-n" || part === "-e")));
+			content = `${parts.join(" ")}${noNewline ? "" : "\n"}`;
+		}
+		return { kind: append ? "edit" : "write", via: append ? "append" : name, paths: [target], content };
+	}
+	return undefined;
+}
+
+/**
+ * The files a command changes, when it does nothing but change files: an optional leading
+ * `cd DIR` and `mkdir -p DIR`, then one or more `sed -i` / `perl -pi` commands, or a
+ * single heredoc or echo/printf redirect. Undefined for anything else.
+ */
+export function detectBashFileEdit(command: string): BashFileEdit | undefined {
+	if (typeof command !== "string" || !command.trim() || command.length > MAX_COMMAND_LENGTH) return undefined;
+	const split = splitHeredoc(command.trim());
+	if (!split || split.rest.trim()) return undefined;
+	const tokens = tokenize(split.head);
+	if (!tokens) return undefined;
+	const commands = splitCommands(tokens);
+	if (!commands || commands.length === 0) return undefined;
+
+	let cd: string | undefined;
+	let index = 0;
+	const first = words(commands[0]);
+	if (first?.[0] === "cd" && first.length === 2 && isPlainPath(first[1])) {
+		cd = first[1];
+		index++;
+	}
+	while (index < commands.length) {
+		const mkdir = words(commands[index]);
+		if (mkdir?.[0] !== "mkdir" || !mkdir.slice(1).every((arg) => arg === "-p" || isPlainPath(arg))) break;
+		index++;
+	}
+	const rest = commands.slice(index);
+	if (rest.length === 0) return undefined;
+
+	// In-place editors, possibly several in a row.
+	const inPlace: string[] = [];
+	let via: string | undefined;
+	for (const segment of rest) {
+		const args = words(segment);
+		if (!args) {
+			inPlace.length = 0;
+			break;
+		}
+		const files = args[0] === "sed" || args[0] === "gsed" ? parseSed(args.slice(1)) : args[0] === "perl" ? parsePerl(args.slice(1)) : undefined;
+		if (!files) {
+			inPlace.length = 0;
+			break;
+		}
+		const tool = args[0] === "perl" ? "perl" : "sed";
+		via = via && via !== tool ? "shell" : tool;
+		for (const file of files) if (!inPlace.includes(file)) inPlace.push(file);
+	}
+	if (inPlace.length > 0) return { kind: "edit", via: via ?? "sed", paths: inPlace, ...(cd ? { cd } : {}) };
+
+	if (rest.length !== 1) return undefined;
+	const write = parseWrite(rest[0], split.expands ? undefined : split.body);
+	return write ? { ...write, ...(cd ? { cd } : {}) } : undefined;
+}