@oh-my-pi/pi-coding-agent 14.5.3 → 14.5.5

package/src/tools/{grep.ts → search.ts}

@@ -8,16 +8,17 @@ import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
-import grepDescription from "../prompts/tools/grep.md" with { type: "text" };
+import searchDescription from "../prompts/tools/search.md" with { type: "text" };
 import { DEFAULT_MAX_COLUMN, type TruncationResult, truncateHead } from "../session/streaming-output";
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
-import { createFileRecorder } from "./file-recorder";
+import { createFileRecorder, formatResultPath } from "./file-recorder";
 import { formatGroupedFiles } from "./grouped-file-output";
 import { formatMatchLine } from "./match-line-format";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
 import {
+	formatPathRelativeToCwd,
 	hasGlobPathChars,
 	normalizePathLikeInput,
 	parseSearchPath,
@@ -34,7 +35,7 @@ import {
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const grepSchema = Type.Object({
+const searchSchema = Type.Object({
 	pattern: Type.String({ description: "regex pattern", examples: ["function\\s+\\w+", "TODO"] }),
 	path: Type.String({
 		description: "file, directory, glob, comma-separated paths, or internal URL to search",
@@ -45,11 +46,11 @@ const grepSchema = Type.Object({
 	skip: Type.Optional(Type.Number({ description: "matches to skip", default: 0 })),
 });
 
-export type GrepToolInput = Static<typeof grepSchema>;
+export type SearchToolInput = Static<typeof searchSchema>;
 
 const DEFAULT_MATCH_LIMIT = 20;
 
-export interface GrepToolDetails {
+export interface SearchToolDetails {
 	truncation?: TruncationResult;
 	matchLimitReached?: number;
 	resultLimitReached?: number;
@@ -68,18 +69,18 @@ export interface GrepToolDetails {
 	displayContent?: string;
 }
 
-type GrepParams = Static<typeof grepSchema>;
+type SearchParams = Static<typeof searchSchema>;
 
-export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
-	readonly name = "grep";
-	readonly label = "Grep";
+export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDetails> {
+	readonly name = "search";
+	readonly label = "Search";
 	readonly description: string;
-	readonly parameters = grepSchema;
+	readonly parameters = searchSchema;
 	readonly strict = true;
 
 	constructor(private readonly session: ToolSession) {
 		const displayMode = resolveFileDisplayMode(session);
-		this.description = prompt.render(grepDescription, {
+		this.description = prompt.render(searchDescription, {
 			IS_HASHLINE_MODE: displayMode.hashLines,
 			IS_LINE_NUMBER_MODE: !displayMode.hashLines && displayMode.lineNumbers,
 		});
@@ -87,11 +88,11 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 
 	async execute(
 		_toolCallId: string,
-		params: GrepParams,
+		params: SearchParams,
 		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<GrepToolDetails>,
+		_onUpdate?: AgentToolUpdateCallback<SearchToolDetails>,
 		_toolContext?: AgentToolContext,
-	): Promise<AgentToolResult<GrepToolDetails>> {
+	): Promise<AgentToolResult<SearchToolDetails>> {
 		const { pattern, path: searchDir, i, gitignore, skip } = params;
 
 		return untilAborted(signal, async () => {
@@ -104,18 +105,15 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			if (normalizedSkip < 0 || !Number.isFinite(normalizedSkip)) {
 				throw new ToolError("Skip must be a non-negative number");
 			}
-			const normalizedContextBefore = this.session.settings.get("grep.contextBefore");
-			const normalizedContextAfter = this.session.settings.get("grep.contextAfter");
+			const normalizedContextBefore = this.session.settings.get("search.contextBefore");
+			const normalizedContextAfter = this.session.settings.get("search.contextAfter");
 			const ignoreCase = i ?? false;
 			const useGitignore = gitignore ?? true;
 			const patternHasNewline = normalizedPattern.includes("\n") || normalizedPattern.includes("\\n");
 			const effectiveMultiline = patternHasNewline;
 
 			const useHashLines = resolveFileDisplayMode(this.session).hashLines;
-			const formatScopePath = (targetPath: string): string => {
-				const relative = path.relative(this.session.cwd, targetPath).replace(/\\/g, "/");
-				return relative.length === 0 ? "." : relative;
-			};
+			const formatScopePath = (targetPath: string): string => formatPathRelativeToCwd(targetPath, this.session.cwd);
 			let searchPath: string;
 			let scopePath: string;
 			let exactFilePaths: string[] | undefined;
@@ -131,7 +129,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				}
 				const resource = await internalRouter.resolve(rawPath);
 				if (!resource.sourcePath) {
-					throw new ToolError(`Cannot grep internal URL without a backing file: ${rawPath}`);
+					throw new ToolError(`Cannot search internal URL without a backing file: ${rawPath}`);
 				}
 				searchPath = resource.sourcePath;
 				scopePath = formatScopePath(searchPath);
@@ -225,14 +223,8 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				throw err;
 			}
 
-			const formatPath = (filePath: string): string => {
-				// returns paths starting with / (the virtual root)
-				const cleanPath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
-				if (isDirectory) {
-					return cleanPath.replace(/\\/g, "/");
-				}
-				return path.basename(cleanPath);
-			};
+			const formatPath = (filePath: string): string =>
+				formatResultPath(filePath, isDirectory, searchPath, this.session.cwd);
 
 			// Build output
 			const roundRobinSelect = (matches: GrepMatch[], limit: number): GrepMatch[] => {
@@ -273,7 +265,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			const { record: recordFile, list: fileList } = createFileRecorder();
 			const fileMatchCounts = new Map<string, number>();
 			if (selectedMatches.length === 0) {
-				const details: GrepToolDetails = {
+				const details: SearchToolDetails = {
 					scopePath,
 					matchCount: 0,
 					fileCount: 0,
@@ -356,7 +348,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 			const output = truncation.content;
 			const truncated = Boolean(matchLimitReached || result.limitReached || truncation.truncated || linesTruncated);
-			const details: GrepToolDetails = {
+			const details: SearchToolDetails = {
 				scopePath,
 				matchCount: selectedMatches.length,
 				fileCount: fileList.length,
@@ -387,7 +379,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 // TUI Renderer
 // =============================================================================
 
-interface GrepRenderArgs {
+interface SearchRenderArgs {
 	pattern: string;
 	path?: string;
 	i?: boolean;
@@ -397,9 +389,9 @@ interface GrepRenderArgs {
 
 const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
 
-export const grepToolRenderer = {
+export const searchToolRenderer = {
 	inline: true,
-	renderCall(args: GrepRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+	renderCall(args: SearchRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const meta: string[] = [];
 		if (args.path) meta.push(`in ${args.path}`);
 		if (args.i) meta.push("case:insensitive");
@@ -407,17 +399,17 @@ export const grepToolRenderer = {
 		if (args.skip !== undefined && args.skip > 0) meta.push(`skip:${args.skip}`);
 
 		const text = renderStatusLine(
-			{ icon: "pending", title: "Grep", description: args.pattern || "?", meta },
+			{ icon: "pending", title: "Search", description: args.pattern || "?", meta },
 			uiTheme,
 		);
 		return new Text(text, 0, 0);
 	},
 
 	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: GrepToolDetails; isError?: boolean },
+		result: { content: Array<{ type: string; text?: string }>; details?: SearchToolDetails; isError?: boolean },
 		options: RenderResultOptions,
 		uiTheme: Theme,
-		args?: GrepRenderArgs,
+		args?: SearchRenderArgs,
 	): Component {
 		const details = result.details;
 
@@ -436,7 +428,7 @@ export const grepToolRenderer = {
 			const lines = textContent.split("\n").filter(line => line.trim() !== "");
 			const description = args?.pattern ?? undefined;
 			const header = renderStatusLine(
-				{ icon: "success", title: "Grep", description, meta: [formatCount("item", lines.length)] },
+				{ icon: "success", title: "Search", description, meta: [formatCount("item", lines.length)] },
 				uiTheme,
 			);
 			let cached: RenderCache | undefined;
@@ -476,7 +468,7 @@ export const grepToolRenderer = {
 
 		if (matchCount === 0) {
 			const header = renderStatusLine(
-				{ icon: "warning", title: "Grep", description: args?.pattern, meta: ["0 matches"] },
+				{ icon: "warning", title: "Search", description: args?.pattern, meta: ["0 matches"] },
 				uiTheme,
 			);
 			return new Text([header, formatEmptyMessage("No matches found", uiTheme)].join("\n"), 0, 0);
@@ -488,7 +480,7 @@ export const grepToolRenderer = {
 		if (truncated) meta.push(uiTheme.fg("warning", "truncated"));
 		const description = args?.pattern ?? undefined;
 		const header = renderStatusLine(
-			{ icon: truncated ? "warning" : "success", title: "Grep", description, meta },
+			{ icon: truncated ? "warning" : "success", title: "Search", description, meta },
 			uiTheme,
 		);
 

package/src/tools/write.ts

@@ -19,6 +19,7 @@ import { parseArchivePathCandidates } from "./archive-reader";
 import { assertEditableFile } from "./auto-generated-guard";
 import { invalidateFsScanAfterWrite } from "./fs-cache-invalidation";
 import { type OutputMeta, outputMeta } from "./output-meta";
+import { formatPathRelativeToCwd } from "./path-utils";
 import { enforcePlanModeWrite, resolvePlanPath } from "./plan-mode-guard";
 import {
 	formatDiagnostics,
@@ -212,7 +213,6 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 	}
 
 	async #writeArchiveEntry(
-		displayPath: string,
 		content: string,
 		resolvedArchivePath: ResolvedArchiveWritePath,
 	): Promise<AgentToolResult<WriteToolDetails>> {
@@ -278,8 +278,11 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		}
 
 		invalidateFsScanAfterWrite(resolvedArchivePath.absolutePath);
+		const outputPath = `${formatPathRelativeToCwd(resolvedArchivePath.absolutePath, this.session.cwd)}:${
+			resolvedArchivePath.archiveSubPath
+		}`;
 		return {
-			content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${displayPath}` }],
+			content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${outputPath}` }],
 			details: {},
 		};
 	}
@@ -426,7 +429,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 					op: resolvedArchivePath.exists ? "update" : "create",
 				});
 
-				const archiveResult = await this.#writeArchiveEntry(path, cleanContent, resolvedArchivePath);
+				const archiveResult = await this.#writeArchiveEntry(cleanContent, resolvedArchivePath);
 				if (stripped) {
 					const firstText = archiveResult.content.find(
 						(block): block is { type: "text"; text: string } =>
@@ -468,7 +471,8 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 			const diagnostics = await this.#writethrough(absolutePath, cleanContent, signal, undefined, batchRequest);
 			invalidateFsScanAfterWrite(absolutePath);
 
-			let resultText = `Successfully wrote ${cleanContent.length} bytes to ${path}`;
+			const displayPath = formatPathRelativeToCwd(absolutePath, this.session.cwd);
+			let resultText = `Successfully wrote ${cleanContent.length} bytes to ${displayPath}`;
 			if (stripped) {
 				resultText += `\nNote: auto-stripped hashline display prefixes from content before writing.`;
 			}

package/src/web/search/index.ts

@@ -205,7 +205,7 @@ export async function runSearchQuery(
  * Supports Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Z.AI, SearXNG, and Synthetic providers with automatic fallback.
  * Session is accepted for interface consistency but not used.
  */
-export class SearchTool implements AgentTool<typeof webSearchSchema, SearchRenderDetails> {
+export class WebSearchTool implements AgentTool<typeof webSearchSchema, SearchRenderDetails> {
 	readonly name = "web_search";
 	readonly label = "Web Search";
 	readonly description: string;

package/src/edit/block.ts

@@ -1,308 +0,0 @@
-/**
- * Block-balanced delimiter finder used by the `splice_block` verb.
- *
- * Tokenizes source text to skip strings and comments, then walks a stack of
- * open delimiters to identify the enclosing balanced block for a target line.
- *
- * This is intentionally language-agnostic over the C-family (C, C++, Rust,
- * Go, Java, JS/TS, C#, Swift, Kotlin, Scala, …): it understands `// line`,
- * `/* block * /` comments, double-quoted, single-quoted, and backtick strings
- * with backslash escapes. It does NOT attempt to parse raw string literals,
- * Python triple-quoted strings, or YAML/Python indent-significant blocks —
- * those are out of scope for v1.
- */
-
-export type DelimiterKind = "{" | "(" | "[";
-
-export interface BlockRange {
-	/** Byte/character offset of the opening delimiter. */
-	openOffset: number;
-	/** Byte/character offset just after the closing delimiter. */
-	closeOffsetExclusive: number;
-	/** Offset of first character after the opener (start of body). */
-	bodyStart: number;
-	/** Offset of the closing delimiter character. */
-	bodyEnd: number;
-	/** 1-indexed line number of the opener. */
-	openLine: number;
-	/** Byte/character offset of the opener line start. */
-	openLineStart: number;
-	/** 1-indexed line number of the closer. */
-	closeLine: number;
-	/** True when opener and closer are on the same line. */
-	sameLine: boolean;
-	/** Whitespace prefix of the opener's line. */
-	openerLineIndent: string;
-	/**
-	 * Whitespace prefix of the first non-blank body line, or `null` when the
-	 * body has no non-blank line.
-	 */
-	bodyLineIndent: string | null;
-	/** Body text exactly as it appears between the delimiters. */
-	bodyText: string;
-	/** Total enclosing blocks of the requested kind before depth selection. */
-	enclosingCount: number;
-}
-
-interface BraceEvent {
-	kind: DelimiterKind | ")" | "]" | "}";
-	offset: number;
-}
-
-const OPENERS: Record<DelimiterKind, string> = { "{": "{", "(": "(", "[": "[" };
-const CLOSERS: Record<DelimiterKind, string> = { "{": "}", "(": ")", "[": "]" };
-
-/**
- * Walk `text` and emit positions of opening and closing delimiters that lie
- * outside strings and comments.
- */
-export function scanDelimiters(text: string): BraceEvent[] {
-	const out: BraceEvent[] = [];
-	const len = text.length;
-	let i = 0;
-	while (i < len) {
-		const ch = text[i]!;
-		// Line comment `// …` to end of line.
-		if (ch === "/" && text[i + 1] === "/") {
-			i += 2;
-			while (i < len && text[i] !== "\n") i++;
-			continue;
-		}
-		// Hash line comment `# …` for shell/Python-like — but only when at start
-		// of a token, to avoid mangling C preprocessor lines (`#include`). We
-		// treat any `#` at column 0 or after whitespace as a line comment, which
-		// is a heuristic that's also fine for `#include` (no braces follow on
-		// the same line in practice for our use case).
-		if (ch === "#" && (i === 0 || text[i - 1] === "\n" || text[i - 1] === " " || text[i - 1] === "\t")) {
-			// Not enabled: too aggressive for C/C++/Rust files. Skip.
-		}
-		// Block comment `/* … */`.
-		if (ch === "/" && text[i + 1] === "*") {
-			i += 2;
-			while (i < len && !(text[i] === "*" && text[i + 1] === "/")) i++;
-			if (i < len) i += 2;
-			continue;
-		}
-		// String literals: ", ', `. Backslash-escape aware.
-		if (ch === '"' || ch === "'" || ch === "`") {
-			const quote = ch;
-			i++;
-			while (i < len) {
-				const c = text[i]!;
-				if (c === "\\") {
-					i += 2;
-					continue;
-				}
-				if (c === quote) {
-					i++;
-					break;
-				}
-				if (c === "\n" && (quote === '"' || quote === "'")) {
-					// Unterminated string; stop scanning this literal so we
-					// don't swallow the rest of the file.
-					break;
-				}
-				i++;
-			}
-			continue;
-		}
-		if (ch === "{" || ch === "(" || ch === "[") {
-			out.push({ kind: ch, offset: i });
-		} else if (ch === "}" || ch === ")" || ch === "]") {
-			out.push({ kind: ch, offset: i });
-		}
-		i++;
-	}
-	return out;
-}
-
-interface OpenFrame {
-	kind: DelimiterKind;
-	offset: number;
-}
-
-/**
- * Build a list of balanced (open, close) ranges by walking the events from
- * `scanDelimiters`. Mismatched closers are skipped (the file may be partially
- * malformed), and unclosed openers at EOF are dropped.
- */
-function pairBlocks(events: BraceEvent[]): { open: OpenFrame; closeOffset: number }[] {
-	const stack: OpenFrame[] = [];
-	const pairs: { open: OpenFrame; closeOffset: number }[] = [];
-	for (const ev of events) {
-		if (ev.kind === "{" || ev.kind === "(" || ev.kind === "[") {
-			stack.push({ kind: ev.kind, offset: ev.offset });
-			continue;
-		}
-		// Closer.
-		const expected: DelimiterKind | null =
-			ev.kind === "}" ? "{" : ev.kind === ")" ? "(" : ev.kind === "]" ? "[" : null;
-		if (!expected) continue;
-		// Pop until we find the matching opener, but only commit pairs when
-		// kinds match. This tolerates small skews from raw strings or other
-		// unsupported constructs without exploding the search.
-		const top = stack[stack.length - 1];
-		if (top?.kind === expected) {
-			stack.pop();
-			pairs.push({ open: top, closeOffset: ev.offset });
-		}
-	}
-	return pairs;
-}
-
-function lineToOffset(text: string, line: number): number {
-	let n = 1;
-	let i = 0;
-	while (i < text.length && n < line) {
-		if (text[i] === "\n") n++;
-		i++;
-	}
-	return i;
-}
-
-function offsetToLine(text: string, offset: number): number {
-	let n = 1;
-	for (let i = 0; i < offset && i < text.length; i++) {
-		if (text[i] === "\n") n++;
-	}
-	return n;
-}
-
-function lineIndentAt(text: string, lineNumber: number): string {
-	const start = lineToOffset(text, lineNumber);
-	let i = start;
-	while (i < text.length && (text[i] === " " || text[i] === "\t")) i++;
-	return text.slice(start, i);
-}
-
-function extractRange(text: string, start: number, end: number): string {
-	return text.slice(start, end);
-}
-
-export interface FindBlockOptions {
-	kind?: DelimiterKind;
-	depth?: number;
-}
-
-export interface FindBlockError {
-	message: string;
-}
-
-/**
- * Find the enclosing balanced block of `kind` containing `targetLine`
- * (1-indexed), at the requested ancestor `depth` (0 = innermost).
- *
- * Returns an error object when no such block exists.
- */
-export function findEnclosingBlock(
-	text: string,
-	targetLine: number,
-	options: FindBlockOptions = {},
-): BlockRange | FindBlockError {
-	const kind: DelimiterKind = options.kind ?? "{";
-	const depth = Math.max(0, Math.floor(options.depth ?? 0));
-
-	const events = scanDelimiters(text);
-	const pairs = pairBlocks(events);
-
-	// Lines (1-indexed) that bracket the target are considered to contain it.
-	// This handles same-line `{ x }` blocks too (openLine == closeLine ==
-	// targetLine).
-	const enclosing = pairs
-		.filter(p => p.open.kind === kind)
-		.map(p => ({
-			open: p.open,
-			closeOffset: p.closeOffset,
-			openLine: offsetToLine(text, p.open.offset),
-			closeLine: offsetToLine(text, p.closeOffset),
-		}))
-		.filter(p => p.openLine <= targetLine && targetLine <= p.closeLine);
-	if (enclosing.length === 0) {
-		return {
-			message: `No enclosing \`${kind}\` block contains line ${targetLine}.`,
-		};
-	}
-	// Default ordering is innermost first (largest open offset among containers).
-	// When both candidates are entirely on the target line, prefer the outermost
-	// same-line block so anchoring a call line targets the containing call before
-	// nested argument calls such as `int(port)`. Multi-line nesting keeps the
-	// existing innermost-first behavior.
-	enclosing.sort((a, b) => {
-		const aSingle = a.openLine === targetLine && a.closeLine === targetLine;
-		const bSingle = b.openLine === targetLine && b.closeLine === targetLine;
-		if (aSingle && bSingle) return a.open.offset - b.open.offset;
-		return b.open.offset - a.open.offset;
-	});
-	if (depth >= enclosing.length) {
-		return {
-			message: `Requested depth ${depth} exceeds available enclosing \`${kind}\` blocks (${enclosing.length}).`,
-		};
-	}
-	const chosen = enclosing[depth]!;
-	const openOffset = chosen.open.offset;
-	const closeOffset = chosen.closeOffset;
-	const bodyStart = openOffset + 1;
-	const bodyEnd = closeOffset;
-	const openLine = chosen.openLine;
-	const closeLine = chosen.closeLine;
-	const openLineStart = lineToOffset(text, openLine);
-	const openerLineIndent = lineIndentAt(text, openLine);
-	const bodyText = extractRange(text, bodyStart, bodyEnd);
-	const bodyLineIndent = computeBodyLineIndent(text, bodyStart, bodyEnd);
-	return {
-		openOffset,
-		closeOffsetExclusive: closeOffset + 1,
-		bodyStart,
-		bodyEnd,
-		openLine,
-		openLineStart,
-		closeLine,
-		sameLine: openLine === closeLine,
-		openerLineIndent,
-		bodyLineIndent,
-		bodyText,
-		enclosingCount: enclosing.length,
-	};
-}
-
-function computeBodyLineIndent(text: string, bodyStart: number, bodyEnd: number): string | null {
-	// Scan body for the first line whose non-whitespace character lives within
-	// [bodyStart, bodyEnd). Return that line's leading whitespace prefix.
-	let i = bodyStart;
-	// Step over the rest of the opener's line (it may contain trailing
-	// whitespace but not body content we want to use as the indent reference).
-	while (i < bodyEnd && text[i] !== "\n") i++;
-	while (i < bodyEnd) {
-		// At line boundary; skip the newline.
-		if (text[i] === "\n") i++;
-		const lineStart = i;
-		while (i < bodyEnd && (text[i] === " " || text[i] === "\t")) i++;
-		// Skip blank lines.
-		if (i < bodyEnd && text[i] !== "\n") {
-			return text.slice(lineStart, i);
-		}
-		// Skip to end of line.
-		while (i < bodyEnd && text[i] !== "\n") i++;
-	}
-	return null;
-}
-
-/**
- * Verify that the agent's body has balanced delimiters of `kind`. Returns an
- * error message when unbalanced, or `null` when fine.
- */
-export function checkBodyBraceBalance(body: string, kind: DelimiterKind): string | null {
-	const events = scanDelimiters(body);
-	let opens = 0;
-	let closes = 0;
-	const opener = OPENERS[kind];
-	const closer = CLOSERS[kind];
-	for (const e of events) {
-		if (e.kind === opener) opens++;
-		else if (e.kind === closer) closes++;
-	}
-	if (opens !== closes) {
-		return `Replacement body has unbalanced \`${opener}\`/\`${closer}\` (open=${opens}, close=${closes}).`;
-	}
-	return null;
-}