pi-hashline-edit-pro 2.6.5 → 2.7.1

package/src/hashline/resolve.ts

@@ -1,12 +1,11 @@
 import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine } from "../utils";
-import { HASH_SEP, HASH_RUN, HL_BARE_PREFIX_RE, HL_PREFIX_PLUS_RE, HL_PREFIX_MINUS_RE, canon } from "./hash";
+import { HASH_SEP, HASH_RUN, stripRowPrefix, canon } from "./hash";
 import { parseHashRef, parseText, type Anchor } from "./parse";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
 
 export type RAnchor = {
 	line: number;
 	hash: string;
-	hashMatched: boolean;
 };
 
 export type HEdit = { content_lines: string[]; hash_bounds: [Anchor, Anchor] };
@@ -56,7 +55,6 @@ function resAnchorFromMap(
 		return {
 			line: hashMatches[0]!,
 			hash: ref.hash,
-			hashMatched: true,
 		};
 	}
 	return { ref, kind: "ambiguous", candidates: hashMatches };
@@ -74,6 +72,19 @@ function assertAligned(
 	}
 }
 
+export function fmtRow(hash: string, line: string): string {
+	return `${hash}${HASH_SEP}${line}`;
+}
+
+export function fmtRegion(hashes: string[], lines: string[]): string {
+	if (hashes.length !== lines.length) {
+		throw new Error(
+			`fmtRegion: hashes.length (${hashes.length}) must match lines.length (${lines.length}).`,
+		);
+	}
+	return lines.map((line, index) => fmtRow(hashes[index]!, line)).join("\n");
+}
+
 export function fmtMismatchWithHashes(
   mismatches: HMismatch[],
   fileLines: string[],
@@ -164,26 +175,29 @@ function assertItem(edit: Record<string, unknown>): void {
 
 export const ANCHOR_ROW_RE = new RegExp(`^([+-]?)(${HASH_RUN})│`);
 
+export function stripAnchorRow(
+	trimmed: string,
+	entryLabel: string,
+	warnings?: string[],
+): string {
+	const match = trimmed.match(ANCHOR_ROW_RE);
+	if (!match) return trimmed;
+	const marker =
+		match[1] === "+"
+			? "diff-preview marker"
+			: match[1] === "-"
+				? 'leading "-" marker'
+				: '"HASH│" prefix';
+	warnings?.push(`[E_BAD_REF] Stripped ${marker} from ${entryLabel} "${trimmed}".`);
+	return match[2]!;
+}
+
 export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
   assertItem(edit as Record<string, unknown>);
 
   const replaceLines = parseText(edit.replacement_lines, warnings);
   const bounds = [edit.remove_from, edit.remove_to].map((ref) => {
-    const trimmed = ref.trim();
-    const match = trimmed.match(ANCHOR_ROW_RE);
-    if (match) {
-      let message: string;
-      if (match[1] === "+") {
-        message = `[E_BAD_REF] Stripped diff-preview marker from remove_from/remove_to entry "${trimmed}".`;
-      } else if (match[1] === "-") {
-        message = `[E_BAD_REF] Stripped leading "-" marker from remove_from/remove_to entry "${trimmed}".`;
-      } else {
-        message = `[E_BAD_REF] Stripped "HASH│" prefix from remove_from/remove_to entry "${trimmed}".`;
-      }
-      warnings?.push(message);
-      return match[2]!;
-    }
-    return ref;
+    return stripAnchorRow(ref.trim(), "remove_from/remove_to entry", warnings);
   }) as [string, string];
   return {
     content_lines: replaceLines,
@@ -210,10 +224,10 @@ export function stripBarePrefixes(
 	const fileHashSet = new Set(fileHashes);
 	const stripped: { lineIndex: number; matched: boolean }[] = [];
 	const contentLines = edit.content_lines.map((line, lineIndex) => {
-		const match = line.match(HL_BARE_PREFIX_RE);
-		if (!match) return line;
-		stripped.push({ lineIndex, matched: fileHashSet.has(match[1]!) });
-		return line.slice(match[0].length);
+		const result = stripRowPrefix(line);
+		if (result.kind !== "bare") return line;
+		stripped.push({ lineIndex, matched: fileHashSet.has(result.hash ?? "") });
+		return result.text;
 	});
 	if (stripped.length === 0) return edit;
 	const locations = stripped
@@ -236,17 +250,10 @@ export function stripDiffPrefixes(
 ): HEdit {
 	const stripped: number[] = [];
 	const contentLines = edit.content_lines.map((line, lineIndex) => {
-		const plus = line.match(HL_PREFIX_PLUS_RE);
-		if (plus) {
-			stripped.push(lineIndex);
-			return line.slice(plus[0].length);
-		}
-		const minus = line.match(HL_PREFIX_MINUS_RE);
-		if (minus) {
-			stripped.push(lineIndex);
-			return line.slice(minus[0].length);
-		}
-		return line;
+		const result = stripRowPrefix(line);
+		if (result.kind !== "plus" && result.kind !== "minus") return line;
+		stripped.push(lineIndex);
+		return result.text;
 	});
 	if (stripped.length === 0) return edit;
 	const locations = stripped.map((i) => `replacement_lines line ${i + 1}`).join(", ");
@@ -473,13 +480,36 @@ export function valEdit(
 	};
 }
 
+export function resolveAnchorLine(
+	ref: Anchor,
+	fileLines: string[],
+	fileHashes: string[],
+	filePath?: string,
+): number {
+	const { resolved, mismatches } = valEdit(
+		{ hash_bounds: [ref, ref], content_lines: [] },
+		fileLines,
+		fileHashes,
+		[],
+		undefined,
+	);
+	if (mismatches.length > 0 || !resolved) {
+		const feedback = fmtMismatchWithHashes(
+			mismatches,
+			fileLines,
+			fileHashes,
+			filePath,
+		);
+		throw new AnchorMismatchError(feedback.text, feedback.hashes);
+	}
+	return resolved.hash_bounds[0].line;
+}
+
 export class RangeStaleError extends Error {
-  readonly firstMismatchLine: number;
   readonly rangeHashes: string[];
-  constructor(message: string, firstMismatchLine: number, rangeHashes: string[]) {
+  constructor(message: string, rangeHashes: string[]) {
     super(message);
     this.name = "RangeStaleError";
-    this.firstMismatchLine = firstMismatchLine;
     this.rangeHashes = rangeHashes;
   }
 }
@@ -516,7 +546,7 @@ export function assertRangeServed(
   for (let line = startLine; line < startLine + shownLength; line++) {
     const hash = fileHashes[line - 1]!;
     shownHashes.push(hash);
-    rows.push(`${hash}${HASH_SEP}${fileLines[line - 1]}`);
+    rows.push(fmtRow(hash, fileLines[line - 1]));
   }
   const location = filePath ? ` in ${filePath}` : "";
   const first = mismatchLines[0]!;
@@ -530,7 +560,7 @@ export function assertRangeServed(
       : "";
   const message =
     `[E_RANGE_STALE] ${mismatchText} what was shown. Nothing was modified. Current range with fresh anchors:\n\n${rows.join("\n")}${capHint}`;
-  throw new RangeStaleError(message, first, shownHashes);
+  throw new RangeStaleError(message, shownHashes);
 }
 
 export { warnUnicodeEsc };

package/src/insert.ts

@@ -0,0 +1,222 @@
+import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { constants } from "fs";
+import { execPipeline, type ReqParams, type ReplaceDetails } from "./replace";
+import { commitEdit } from "./commit";
+import { readNormFile, type NormFile } from "./file-reader";
+import { resolveTarget } from "./fs-write";
+import { MAX_HASH_LINES, parseHashRef, resolveAnchorLine, type Anchor } from "./hashline";
+import { stripAnchorRow } from "./hashline/resolve";
+import { toCwd } from "./paths";
+import { loadP, loadGuide } from "./prompts";
+import { normReq } from "./replace-normalize";
+import { genDiff } from "./replace-diff";
+import { makeRenderCall, renderEditResult, type RPreview, type RRState } from "./replace-render";
+import { abortIf, isRec, makePrepareArguments, rejectUnknownFields, splitLines } from "./utils";
+import { clearBoundaryBypass } from "./boundary-bypass";
+
+const INSERT_KS = new Set(["path", "anchor", "direction", "lines"]);
+
+export interface InsertReq {
+  path: string;
+  anchor: string;
+  direction: "before" | "after";
+  lines: string[];
+}
+
+export function assertInsertReq(request: unknown): asserts request is InsertReq {
+  if (!isRec(request)) {
+    throw new Error("[E_BAD_SHAPE] Insert request must be an object.");
+  }
+  rejectUnknownFields(request, INSERT_KS, "Insert request");
+  if (typeof request.path !== "string" || request.path.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Insert request requires a non-empty "path" string.');
+  }
+  if (typeof request.anchor !== "string" || request.anchor.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Insert request requires an "anchor" string (3-char hash from read output).');
+  }
+  if (request.direction !== "before" && request.direction !== "after") {
+    throw new Error('[E_BAD_SHAPE] Insert request "direction" must be "before" or "after".');
+  }
+  if (!Array.isArray(request.lines) || request.lines.some((line) => typeof line !== "string")) {
+    throw new Error('[E_BAD_SHAPE] Insert request requires "lines" as an array of strings, one element per line.');
+  }
+}
+
+const insertToolSchema = Type.Object(
+  {
+    path: Type.String({
+      description:
+        "Path to the file to edit",
+    }),
+    anchor: Type.String({
+      description:
+        'Bare 3-char HASH only (e.g. "aB3"): copy just the hash from the leftmost column of a read row like `aB3│content`; never the line content. A pasted diff row like `+aB3│x` or a `HASH│` prefix is stripped automatically with a warning. The anchored line is preserved; the new lines go after or before it.',
+    }),
+    direction: Type.Union(
+      [
+        Type.Literal("after", { description: "Insert the lines after the anchor line" }),
+        Type.Literal("before", { description: "Insert the lines before the anchor line" }),
+      ],
+      { description: '"after" or "before"' },
+    ),
+    lines: Type.Array(
+      Type.String({
+        description:
+          "One line to insert. Each element is exactly one line; do not embed \\n inside an element: use separate elements.",
+      }),
+      {
+        description:
+          'Lines to insert as an array of strings, one element per line. Use [""] for a blank line. The anchor line is preserved; never include it in lines.',
+      }
+    ),
+  },
+  { additionalProperties: false },
+);
+
+function parseInsertAnchor(raw: string): { ref: Anchor; warnings: string[] } {
+  const trimmedAnchor = raw.trim();
+  const warnings: string[] = [];
+  const anchorText = stripAnchorRow(trimmedAnchor, "anchor entry", warnings);
+  return { ref: parseHashRef(anchorText), warnings };
+}
+
+function buildInsertEdit(
+  req: InsertReq,
+  preload: NormFile,
+  ref: Anchor,
+): { editParams: ReqParams; anchorLine: string | undefined } {
+  const fileLines = splitLines(preload.normalized);
+  const line = resolveAnchorLine(ref, fileLines, preload.fileHashes, req.path);
+  const anchorLine = preload.normalized.length === 0 ? undefined : fileLines[line - 1];
+  const editParams: ReqParams = {
+    path: req.path,
+    remove_from: ref.hash,
+    remove_to: ref.hash,
+    replacement_lines:
+      anchorLine === undefined
+        ? [...req.lines]
+        : req.direction === "after"
+          ? [anchorLine, ...req.lines]
+          : [...req.lines, anchorLine],
+  };
+  return { editParams, anchorLine };
+}
+
+export async function insertPreview(request: unknown, cwd: string): Promise<RPreview> {
+  try {
+    const normalized = normReq(request);
+    assertInsertReq(normalized);
+    const { ref } = parseInsertAnchor(normalized.anchor);
+    const preload = await readNormFile(normalized.path, cwd, {
+      accessMode: constants.R_OK,
+      maxLines: MAX_HASH_LINES,
+      noPersist: true,
+    });
+    const { editParams } = buildInsertEdit(normalized, preload, ref);
+    const pipe = await execPipeline(editParams, cwd, {
+      accessMode: constants.R_OK,
+      noPersist: true,
+      preloadedNorm: preload,
+      skipBoundaryDedup: true,
+    });
+    if (pipe.originalNormalized === pipe.result) {
+      return { error: `No changes made to ${normalized.path}. The edit produced identical content.` };
+    }
+    return { diff: genDiff(pipe.originalNormalized, pipe.result, 4, pipe.resultHashes, pipe.originalHashes).diff };
+  } catch (error: unknown) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function getInsertInput(args: unknown): { path?: string; anchor?: string; direction?: "before" | "after"; lines?: string[] } | null {
+  let normalized: unknown;
+  try {
+    normalized = normReq(args);
+  } catch {
+    return null;
+  }
+  if (!isRec(normalized) || typeof normalized.path !== "string") return null;
+  if (
+    typeof normalized.anchor !== "string" ||
+    (normalized.direction !== "before" && normalized.direction !== "after") ||
+    !Array.isArray(normalized.lines) ||
+    normalized.lines.some((line) => typeof line !== "string")
+  ) {
+    return null;
+  }
+  return {
+    path: normalized.path,
+    anchor: normalized.anchor,
+    direction: normalized.direction,
+    lines: normalized.lines,
+  };
+}
+
+type InsertToolDef = ToolDefinition<any, ReplaceDetails, RRState> & { renderShell?: "default" | "self" };
+
+export function buildInsertToolDef(): InsertToolDef {
+  return {
+    name: "insert",
+    label: "Insert",
+    description: loadP("../prompts/insert.md"),
+    promptSnippet: loadP("../prompts/insert-snippet.md"),
+    promptGuidelines: loadGuide("../prompts/insert-guidelines.md"),
+    prepareArguments: makePrepareArguments(),
+    parameters: insertToolSchema,
+    renderShell: "default",
+    renderCall: makeRenderCall(insertPreview, { getInput: getInsertInput, toolName: "insert" }),
+    renderResult(result, { isPartial }, theme, context) {
+      return renderEditResult(
+        result as {
+          content?: Array<{ type: string; text?: string }>;
+          details?: ReplaceDetails;
+        },
+        isPartial,
+        theme,
+        context,
+      );
+    },
+
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const canonical = normReq(params);
+      assertInsertReq(canonical);
+      const req = canonical;
+      const path = req.path;
+      const { ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor);
+      const absolutePath = toCwd(path, ctx.cwd);
+      const mutationTargetPath = await resolveTarget(absolutePath);
+      return withFileMutationQueue(mutationTargetPath, async () => {
+        abortIf(signal);
+        const preload = await readNormFile(path, ctx.cwd, {
+          signal,
+          accessMode: constants.R_OK | constants.W_OK,
+          maxLines: MAX_HASH_LINES,
+        });
+        const { editParams, anchorLine } = buildInsertEdit(req, preload, ref);
+        const pipe = await execPipeline(editParams, ctx.cwd, {
+          accessMode: constants.R_OK | constants.W_OK,
+          signal,
+          preloadedNorm: preload,
+          skipBoundaryDedup: true,
+        });
+        return commitEdit(pipe, {
+          path,
+          absolutePath,
+          mutationTargetPath,
+          signal,
+          verb: "inserted",
+          noopNoun: "Insertion",
+          foldedAnchorLines: anchorLine === undefined ? 0 : 1,
+          prefixWarnings: anchorWarnings,
+          onApplied: () => clearBoundaryBypass(mutationTargetPath),
+        });
+      });
+    },
+  };
+}
+
+export function regInsert(pi: ExtensionAPI): void {
+  pi.registerTool(buildInsertToolDef());
+}

package/src/replace-diff.ts

@@ -47,6 +47,10 @@ function fmtDiffLine(
   return `${prefix}${hash}${HASH_SEP}${line}`;
 }
 
+function isBlankLine(line: string): boolean {
+  return line.trim().length === 0;
+}
+
 const ELLIPSIS_MARKER: unique symbol = Symbol("ellipsis");
 const isEllipsisMarker = (line: string | symbol): line is symbol =>
   line === ELLIPSIS_MARKER;
@@ -99,15 +103,52 @@ export function genDiff(
       let skipTail = 0;
 
       if (!lastWasChange) {
-        skipStart = Math.max(0, displayLines.length - contextLines);
+        let count = contextLines;
+        if (
+          contextLines > 0 &&
+          displayLines.length > count &&
+          isBlankLine(displayLines[displayLines.length - 1]!)
+        ) {
+          count += 1;
+        }
+        count = Math.min(count, displayLines.length);
+        skipStart = displayLines.length - count;
         linesToShow = displayLines.slice(skipStart);
       } else if (nextPartIsChange && displayLines.length > contextLines * 2) {
-        const tail = displayLines.slice(-contextLines);
-        linesToShow = [...displayLines.slice(0, contextLines), ELLIPSIS_MARKER, ...tail];
-        skipMiddle = displayLines.length - contextLines * 2;
+        let headCount = contextLines;
+        let tailCount = contextLines;
+        if (
+          contextLines > 0 &&
+          displayLines.length - headCount > tailCount &&
+          isBlankLine(displayLines[headCount - 1]!)
+        ) {
+          headCount += 1;
+        }
+        if (
+          contextLines > 0 &&
+          displayLines.length - tailCount > headCount &&
+          isBlankLine(displayLines[displayLines.length - tailCount]!)
+        ) {
+          tailCount += 1;
+        }
+        const middleLen = displayLines.length - headCount - tailCount;
+        if (middleLen > 0) {
+          linesToShow = [
+            ...displayLines.slice(0, headCount),
+            ELLIPSIS_MARKER,
+            ...displayLines.slice(displayLines.length - tailCount),
+          ];
+          skipMiddle = middleLen;
+        } else {
+          linesToShow = displayLines;
+        }
       } else if (!nextPartIsChange && linesToShow.length > contextLines) {
-        linesToShow = linesToShow.slice(0, contextLines);
-        skipTail = displayLines.length - contextLines;
+        let count = contextLines;
+        const firstLine = linesToShow[0];
+        if (contextLines > 0 && typeof firstLine === "string" && isBlankLine(firstLine)) count += 1;
+        count = Math.min(count, linesToShow.length);
+        linesToShow = linesToShow.slice(0, count);
+        skipTail = displayLines.length - count;
       }
 
       if (skipStart > 0) {

package/src/replace-render.ts

@@ -1,3 +1,4 @@
+import { Markdown, Text } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { normReq } from "./replace-normalize";
 import type { ReqParams, ReplaceDetails } from "./replace";
@@ -89,17 +90,18 @@ export function fmtResult(diff: string, theme: FgT): string {
 }
 
 export function fmtCall(
-	args: ReqParams | undefined,
+	args: { path?: string } | undefined,
 	state: RRState,
 	expanded: boolean,
 	theme: CallT,
+	toolName = "replace",
 ): string {
 	const path = args?.path;
 	const pathDisplay =
 		typeof path === "string" && path.length > 0
 			? theme.fg("accent", path)
 			: theme.fg("toolOutput", "...");
-	let text = `${theme.fg("toolTitle", theme.bold("replace"))} ${pathDisplay}`;
+	let text = `${theme.fg("toolTitle", theme.bold(toolName))} ${pathDisplay}`;
 
 	if (!state.preview) {
 		return text;
@@ -209,3 +211,116 @@ export function mkMdTheme(theme: MdTheme) {
 			}),
 	};
 }
+
+export const PREVIEW_DEBOUNCE_MS = 150;
+
+export function reuseText(context: any, content: string): Text {
+	const t = context.lastComponent instanceof Text
+		? context.lastComponent
+		: new Text("", 0, 0);
+	t.setText(content);
+	return t;
+}
+
+export function reuseMarkdown(context: any, content: string, theme: any): Markdown {
+	const m = context.lastComponent instanceof Markdown
+		? context.lastComponent
+		: new Markdown("", 0, 0, mkMdTheme(theme));
+	m.setText(content);
+	return m;
+}
+
+export function makeRenderCall(
+	preview: (args: unknown, cwd: string) => Promise<RPreview>,
+	options: { getInput?: (args: unknown) => { path?: string } | null; toolName?: string } = {},
+) {
+	const getInput = options.getInput ?? getPreviewInput;
+	const toolName = options.toolName ?? "replace";
+	return (args: any, theme: CallT, context: any): Text => {
+		const previewInput = getInput(args);
+		const cancelPendingPreview = () => {
+			if (context.state.previewTimer) {
+				clearTimeout(context.state.previewTimer);
+				context.state.previewTimer = undefined;
+			}
+		};
+		if (context.executionStarted) {
+			cancelPendingPreview();
+			context.state.argsKey = undefined;
+			context.state.preview = undefined;
+			context.state.previewGeneration = (context.state.previewGeneration ?? 0) + 1;
+		} else if (!context.argsComplete || !previewInput) {
+			cancelPendingPreview();
+			context.state.argsKey = undefined;
+			context.state.preview = undefined;
+			context.state.previewGeneration = (context.state.previewGeneration ?? 0) + 1;
+		} else {
+			const argsKey = JSON.stringify(previewInput);
+			if (context.state.argsKey !== argsKey) {
+				cancelPendingPreview();
+				context.state.argsKey = argsKey;
+				context.state.preview = undefined;
+				const previewGeneration = (context.state.previewGeneration ?? 0) + 1;
+				context.state.previewGeneration = previewGeneration;
+				context.state.previewTimer = setTimeout(() => {
+					context.state.previewTimer = undefined;
+					preview(args, context.cwd)
+						.then((result) => {
+							if (
+								context.state.argsKey === argsKey &&
+								context.state.previewGeneration === previewGeneration
+							) {
+								context.state.preview = result;
+								context.invalidate();
+							}
+						})
+						.catch((err: unknown) => {
+							if (
+								context.state.argsKey === argsKey &&
+								context.state.previewGeneration === previewGeneration
+							) {
+								context.state.preview = {
+									error: err instanceof Error ? err.message : String(err),
+								};
+								context.invalidate();
+							}
+						});
+				}, PREVIEW_DEBOUNCE_MS);
+			}
+		}
+		const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+		text.setText(fmtCall(getInput(args) ?? undefined, context.state as RRState, context.expanded, theme, toolName));
+		return text;
+	};
+}
+
+export function renderEditResult(
+	result: { content?: Array<{ type: string; text?: string }>; details?: ReplaceDetails },
+	isPartial: boolean,
+	theme: FgT,
+	context: any,
+): Text | Markdown {
+	if (isPartial) return reuseText(context, theme.fg("warning", "Editing..."));
+	const renderedText = getResultText(result);
+	const renderState = context.state as RRState | undefined;
+	if (renderState) {
+		if (renderState.previewTimer) {
+			clearTimeout(renderState.previewTimer);
+			renderState.previewTimer = undefined;
+		}
+		renderState.preview = undefined;
+		renderState.previewGeneration = (renderState.previewGeneration ?? 0) + 1;
+	}
+	if (context.isError) {
+		return renderedText
+			? reuseText(context, `\n${theme.fg("error", renderedText)}`)
+			: new Text("", 0, 0);
+	}
+	if (isApplied(result.details)) {
+		const appliedText = buildAppliedText(renderedText, result.details, theme);
+		return appliedText ? reuseText(context, appliedText) : new Text("", 0, 0);
+	}
+	if (!renderedText) return new Text("", 0, 0);
+	return reuseMarkdown(context, fmtResultMd(renderedText), theme);
+}
+

package/src/replace-response.ts

@@ -1,8 +1,9 @@
+import type { NEdit } from "./hashline";
 import type { ReplaceDetails } from "./replace";
 import { genDiff, genPatch } from "./replace-diff";
 import { visLines, clipLine } from "./utils";
 
-type TResult = {
+export type TResult = {
 	content: Array<{ type: "text"; text: string }>;
 	isError?: boolean;
 	details: ReplaceDetails;
@@ -27,14 +28,9 @@ export type RMeta = {
   removedLines: number;
 };
 
-type NEditEntry = {
-	loc: string;
-	currentContent: string;
-};
-
 export interface NoopInput {
 	path: string;
-	noopEdit: NEditEntry | undefined;
+	noopEdit: NEdit | undefined;
 	snapshotId?: string;
 	editMeta: RMeta;
 	warnings: string[] | undefined;
@@ -89,7 +85,7 @@ function warnBlock(warnings: string[] | undefined): string {
 	return warnings?.length ? `\n\nWarnings:\n${warnings.join("\n")}` : "";
 }
 
-export function buildNoop(input: NoopInput): TResult {
+export function buildNoop(input: NoopInput, noopNoun = "Replacement"): TResult {
 	const {
 		path,
 		noopEdit,
@@ -100,7 +96,7 @@ export function buildNoop(input: NoopInput): TResult {
 	} = input;
 
 	const noopDetailsText = noopEdit
-		? `Replacement for ${noopEdit.loc} is identical to current content:\n  ${noopEdit.loc}: ${clipLine(noopEdit.currentContent)}`
+		? `${noopNoun} for ${noopEdit.loc} is identical to current content:\n  ${noopEdit.loc}: ${clipLine(noopEdit.currentContent)}`
 		: "The edit produced identical content.";
 	const dedupNote =
 		boundaryRemovedLines !== undefined && boundaryRemovedLines > 0
@@ -129,14 +125,14 @@ export function buildNoop(input: NoopInput): TResult {
 	};
 }
 
-export function buildChanged(input: SuccessInput): TResult {
+export function buildChanged(input: SuccessInput, verb = "replaced"): TResult {
   const { path, result, warnings, snapshotId, originalNormalized, originalHashes, editMeta, resultHashes } = input;
   const resultLines = visLines(result);
   const diffResult = genDiff(originalNormalized, result, 1, resultHashes, originalHashes);
   const addedLines = editMeta.addedLines;
   const removedLines = editMeta.removedLines;
   const warningsBlock = warnBlock(warnings);
-  const successPrefix = `Successfully replaced in ${path}.`;
+  const successPrefix = `Successfully ${verb} in ${path}.`;
   const lineSummary = addedLines > 0 || removedLines > 0
     ? ` Added ${addedLines} line(s), removed ${removedLines} line(s).`
     : "";