pi-readseek 0.1.0

package/src/edit-classify.ts

@@ -0,0 +1,190 @@
+import * as Diff from "diff";
+import { execFile } from "node:child_process";
+import { writeFileSync, mkdtempSync, rmSync } from "node:fs";
+import { resolve } from "node:path";
+import { tmpdir } from "node:os";
+
+export type EditClassification = "no-op" | "whitespace-only" | "semantic" | "mixed";
+
+export interface EditClassifyResult {
+  classification: EditClassification;
+}
+
+export function classifyEdit(oldContent: string, newContent: string): EditClassifyResult {
+  if (oldContent === newContent) {
+    return { classification: "no-op" };
+  }
+
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+
+  // When line counts match, do pairwise comparison
+  if (oldLines.length === newLines.length) {
+    let hasWhitespaceChange = false;
+    let hasSemanticChange = false;
+    for (let i = 0; i < oldLines.length; i++) {
+      if (oldLines[i] === newLines[i]) continue;
+      if (oldLines[i].trim() === newLines[i].trim()) {
+        hasWhitespaceChange = true;
+      } else {
+        hasSemanticChange = true;
+      }
+    }
+    if (hasSemanticChange && hasWhitespaceChange) return { classification: "mixed" };
+    if (hasWhitespaceChange) return { classification: "whitespace-only" };
+    return { classification: "semantic" };
+  }
+
+  // When line counts differ, use diff library to find changes
+  const parts = Diff.diffLines(oldContent, newContent);
+  let hasWhitespaceChange = false;
+  let hasSemanticChange = false;
+
+  for (const part of parts) {
+    if (!part.added && !part.removed) continue;
+
+    const lines = part.value.split("\n");
+    if (lines[lines.length - 1] === "") lines.pop();
+
+    for (const line of lines) {
+      if (line.trim() === "") {
+        hasWhitespaceChange = true;
+      } else {
+        hasSemanticChange = true;
+      }
+    }
+  }
+
+  if (hasSemanticChange && hasWhitespaceChange) return { classification: "mixed" };
+  if (hasWhitespaceChange) return { classification: "whitespace-only" };
+  return { classification: "semantic" };
+}
+
+let difftCachedResult: boolean | null = null;
+
+export function _resetDifftCache(): void {
+  difftCachedResult = null;
+}
+
+export async function isDifftAvailable(): Promise<boolean> {
+  if (difftCachedResult !== null) return difftCachedResult;
+
+  return new Promise<boolean>((resolve) => {
+    execFile("which", ["difft"], (err) => {
+      difftCachedResult = !err;
+      resolve(difftCachedResult);
+    });
+  });
+}
+
+export interface DifftClassifyResult {
+  classification: EditClassification;
+  movedBlocks: number;
+}
+
+function getChunkSideText(side: any): string {
+  if (!side || typeof side !== "object") return "";
+  if (!Array.isArray(side.changes)) return "";
+  return side.changes
+    .map((change: any) => (change && typeof change.content === "string" ? change.content : ""))
+    .join("");
+}
+
+function getChunkOnlySideSignature(chunk: any[]): { side: "lhs" | "rhs"; text: string } | null {
+  let hasLhs = false;
+  let hasRhs = false;
+  let text = "";
+
+  for (const entry of chunk) {
+    if (entry?.lhs) {
+      hasLhs = true;
+      text += getChunkSideText(entry.lhs);
+    }
+    if (entry?.rhs) {
+      hasRhs = true;
+      text += getChunkSideText(entry.rhs);
+    }
+  }
+
+  if (hasLhs === hasRhs) return null;
+  return { side: hasLhs ? "lhs" : "rhs", text };
+}
+
+export function parseDifftJson(json: any): DifftClassifyResult | null {
+  if (!json || typeof json !== "object" || !("status" in json)) return null;
+
+  if (json.status === "unchanged") {
+    return { classification: "whitespace-only", movedBlocks: 0 };
+  }
+
+  if (json.status !== "changed" || !Array.isArray(json.chunks)) {
+    return null;
+  }
+
+  const lhsOnlyChunkTexts: string[] = [];
+  const rhsOnlyChunkTexts: string[] = [];
+  for (const chunk of json.chunks) {
+    if (!Array.isArray(chunk)) continue;
+    const signature = getChunkOnlySideSignature(chunk);
+    if (!signature) continue;
+    if (signature.side === "lhs") lhsOnlyChunkTexts.push(signature.text);
+    if (signature.side === "rhs") rhsOnlyChunkTexts.push(signature.text);
+  }
+
+  const remainingRhs = new Map<string, number>();
+  for (const text of rhsOnlyChunkTexts) {
+    remainingRhs.set(text, (remainingRhs.get(text) ?? 0) + 1);
+  }
+
+  let movedBlocks = 0;
+  for (const text of lhsOnlyChunkTexts) {
+    const count = remainingRhs.get(text) ?? 0;
+    if (count <= 0) continue;
+    movedBlocks++;
+    if (count === 1) remainingRhs.delete(text);
+    else remainingRhs.set(text, count - 1);
+  }
+
+  return { classification: "semantic", movedBlocks };
+
+  return { classification: "semantic", movedBlocks };
+}
+
+export async function runDifftastic(
+  oldContent: string,
+  newContent: string,
+  fileExtension: string,
+): Promise<DifftClassifyResult | null> {
+  const available = await isDifftAvailable();
+  if (!available) return null;
+
+  let tempDir: string | null = null;
+  try {
+    tempDir = mkdtempSync(resolve(tmpdir(), "pi-difft-"));
+    const oldPath = resolve(tempDir, `old.${fileExtension}`);
+    const newPath = resolve(tempDir, `new.${fileExtension}`);
+    writeFileSync(oldPath, oldContent, "utf-8");
+    writeFileSync(newPath, newContent, "utf-8");
+
+    const stdout = await new Promise<string>((resolve, reject) => {
+      execFile(
+        "difft",
+        ["--display=json", oldPath, newPath],
+        { env: { ...process.env, DFT_UNSTABLE: "yes" }, timeout: 10_000 },
+        (err, stdout) => {
+          if (err) return reject(err);
+          resolve(stdout);
+        },
+      );
+    });
+
+    const json = JSON.parse(stdout);
+    return parseDifftJson(json);
+  } catch {
+    return null;
+  } finally {
+    if (tempDir) {
+      try { rmSync(tempDir, { recursive: true, force: true }); } catch { /* ignore */ }
+    }
+  }
+}

package/src/edit-diff.ts

@@ -0,0 +1,354 @@
+import * as Diff from "diff";
+import { computeLineHash } from "./hashline.js";
+
+// ─── Line ending normalization ──────────────────────────────────────────
+
+export function detectLineEnding(content: string): "\r\n" | "\n" {
+	const crlfIdx = content.indexOf("\r\n");
+	const lfIdx = content.indexOf("\n");
+	if (lfIdx === -1 || crlfIdx === -1) return "\n";
+	return crlfIdx < lfIdx ? "\r\n" : "\n";
+}
+
+export function normalizeToLF(text: string): string {
+	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+export function restoreLineEndings(text: string, ending: "\r\n" | "\n"): string {
+	return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+}
+
+export function stripBom(content: string): { bom: string; text: string } {
+	return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
+}
+
+/**
+ * Detect bare \r characters that are NOT part of \r\n sequences.
+ * These cause line-count mismatches between normalizeToLF and external tools (ripgrep, wc).
+ */
+export function hasBareCarriageReturn(content: string): boolean {
+	// Remove all \r\n first, then check if any \r remains
+	return content.replace(/\r\n/g, "").includes("\r");
+}
+
+// ─── Fuzzy text matching ────────────────────────────────────────────────
+
+const SINGLE_QUOTES_RE = /[\u2018\u2019\u201A\u201B]/g;
+const DOUBLE_QUOTES_RE = /[\u201C\u201D\u201E\u201F]/g;
+const HYPHENS_RE = /[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g;
+const UNICODE_SPACES_RE = /[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g;
+
+function normalizeFuzzyChar(ch: string): string {
+	return ch.replace(SINGLE_QUOTES_RE, "'").replace(DOUBLE_QUOTES_RE, '"').replace(HYPHENS_RE, "-").replace(UNICODE_SPACES_RE, " ");
+}
+
+function normalizeForFuzzyMatch(text: string): string {
+	return text
+		.split("\n")
+		.map((line) => line.trimEnd())
+		.join("\n")
+		.replace(SINGLE_QUOTES_RE, "'")
+		.replace(DOUBLE_QUOTES_RE, '"')
+		.replace(HYPHENS_RE, "-")
+		.replace(UNICODE_SPACES_RE, " ");
+}
+
+function buildNormalizedWithMap(text: string): { normalized: string; indexMap: number[] } {
+	const lines = text.split("\n");
+	const normalizedChars: string[] = [];
+	const indexMap: number[] = [];
+	let originalOffset = 0;
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i]!;
+		const trimmed = line.replace(/\s+$/u, "");
+
+		for (let j = 0; j < trimmed.length; j++) {
+			normalizedChars.push(normalizeFuzzyChar(trimmed[j]!));
+			indexMap.push(originalOffset + j);
+		}
+
+		if (i < lines.length - 1) {
+			normalizedChars.push("\n");
+			indexMap.push(originalOffset + line.length);
+		}
+
+		originalOffset += line.length + 1;
+	}
+
+	return { normalized: normalizedChars.join(""), indexMap };
+}
+
+function mapNormalizedSpanToOriginal(
+	indexMap: number[],
+	normalizedStart: number,
+	normalizedLength: number,
+): { index: number; matchLength: number } | null {
+	if (normalizedStart < 0 || normalizedLength <= 0) return null;
+	const normalizedEnd = normalizedStart + normalizedLength;
+	if (normalizedEnd > indexMap.length) return null;
+
+	const start = indexMap[normalizedStart];
+	const end = indexMap[normalizedEnd - 1];
+	if (start === undefined || end === undefined || end < start) return null;
+
+	return { index: start, matchLength: end - start + 1 };
+}
+
+/**
+ * Find `oldText` in `content` with optional fuzzy whitespace/unicode matching.
+ * Always returns an index/length in the original content.
+ */
+export function fuzzyFindText(
+	content: string,
+	oldText: string,
+): { found: boolean; index: number; matchLength: number; usedFuzzyMatch: boolean } {
+	const exactIndex = content.indexOf(oldText);
+	if (exactIndex !== -1) {
+		return { found: true, index: exactIndex, matchLength: oldText.length, usedFuzzyMatch: false };
+	}
+
+	const normalizedNeedle = normalizeForFuzzyMatch(oldText);
+	if (!normalizedNeedle.length) return { found: false, index: -1, matchLength: 0, usedFuzzyMatch: false };
+
+	const { normalized, indexMap } = buildNormalizedWithMap(content);
+	const normalizedIndex = normalized.indexOf(normalizedNeedle);
+	if (normalizedIndex === -1) {
+		return { found: false, index: -1, matchLength: 0, usedFuzzyMatch: false };
+	}
+
+	const mapped = mapNormalizedSpanToOriginal(indexMap, normalizedIndex, normalizedNeedle.length);
+	if (!mapped) {
+		return { found: false, index: -1, matchLength: 0, usedFuzzyMatch: false };
+	}
+
+	return { found: true, index: mapped.index, matchLength: mapped.matchLength, usedFuzzyMatch: true };
+}
+
+/**
+ * Replace `oldText` with `newText` in `content`.
+ * Fuzzy matching only determines target spans; replacement always applies to
+ * the original content (never normalizes the whole file).
+ */
+export type ReplaceTextResult = { content: string; count: number; usedFuzzyMatch: boolean };
+
+export function replaceText(
+	content: string,
+	oldText: string,
+	newText: string,
+	opts: { all?: boolean; fuzzy?: boolean },
+): ReplaceTextResult {
+	if (!oldText.length) return { content, count: 0, usedFuzzyMatch: false };
+	const normalizedNew = normalizeToLF(newText);
+
+	if (opts.all) {
+		const exactCount = content.split(oldText).length - 1;
+		if (exactCount > 0) {
+			return { content: content.split(oldText).join(normalizedNew), count: exactCount, usedFuzzyMatch: false };
+		}
+		if (!opts.fuzzy) return { content, count: 0, usedFuzzyMatch: false };
+
+		const normalizedNeedle = normalizeForFuzzyMatch(oldText);
+		if (!normalizedNeedle.length) return { content, count: 0, usedFuzzyMatch: false };
+
+		const { normalized, indexMap } = buildNormalizedWithMap(content);
+		const spans: Array<{ index: number; matchLength: number }> = [];
+		let searchFrom = 0;
+
+		while (searchFrom <= normalized.length - normalizedNeedle.length) {
+			const pos = normalized.indexOf(normalizedNeedle, searchFrom);
+			if (pos === -1) break;
+			const mapped = mapNormalizedSpanToOriginal(indexMap, pos, normalizedNeedle.length);
+			if (mapped) {
+				const prev = spans[spans.length - 1];
+				if (!prev || mapped.index >= prev.index + prev.matchLength) {
+					spans.push(mapped);
+				}
+			}
+			searchFrom = pos + Math.max(1, normalizedNeedle.length);
+		}
+
+		if (!spans.length) return { content, count: 0, usedFuzzyMatch: false };
+
+		let out = content;
+		for (let i = spans.length - 1; i >= 0; i--) {
+			const span = spans[i]!;
+			out = out.substring(0, span.index) + normalizedNew + out.substring(span.index + span.matchLength);
+		}
+		return { content: out, count: spans.length, usedFuzzyMatch: true };
+	}
+
+	const exactIndex = content.indexOf(oldText);
+	if (exactIndex !== -1) {
+		return {
+			content: content.substring(0, exactIndex) + normalizedNew + content.substring(exactIndex + oldText.length),
+			count: 1,
+			usedFuzzyMatch: false,
+		};
+	}
+
+	if (!opts.fuzzy) return { content, count: 0, usedFuzzyMatch: false };
+
+	const result = fuzzyFindText(content, oldText);
+	if (!result.found) return { content, count: 0, usedFuzzyMatch: false };
+
+	return {
+		content: content.substring(0, result.index) + normalizedNew + content.substring(result.index + result.matchLength),
+		count: 1,
+		usedFuzzyMatch: result.usedFuzzyMatch,
+	};
+}
+
+// ─── Diff generation ────────────────────────────────────────────────────
+
+export function generateDiffString(
+	oldContent: string,
+	newContent: string,
+	contextLines = 4,
+): { diff: string; firstChangedLine: number | undefined } {
+	const parts = Diff.diffLines(oldContent, newContent);
+	const output: string[] = [];
+	const maxLineNum = Math.max(oldContent.split("\n").length, newContent.split("\n").length);
+	const lineNumWidth = String(maxLineNum).length;
+	let oldLineNum = 1;
+	let newLineNum = 1;
+	let lastWasChange = false;
+	let firstChangedLine: number | undefined;
+
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i]!;
+		const raw = part.value.split("\n");
+		if (raw[raw.length - 1] === "") raw.pop();
+
+		if (part.added || part.removed) {
+			if (firstChangedLine === undefined) firstChangedLine = newLineNum;
+			for (const line of raw) {
+				if (part.added) {
+					output.push(`+${String(newLineNum).padStart(lineNumWidth, " ")} ${line}`);
+					newLineNum++;
+				} else {
+					output.push(`-${String(oldLineNum).padStart(lineNumWidth, " ")} ${line}`);
+					oldLineNum++;
+				}
+			}
+			lastWasChange = true;
+			continue;
+		}
+
+		const nextPartIsChange = i < parts.length - 1 && (parts[i + 1]!.added || parts[i + 1]!.removed);
+		if (lastWasChange || nextPartIsChange) {
+			let linesToShow = raw;
+			let skipStart = 0;
+			let skipEnd = 0;
+
+			if (!lastWasChange) {
+				skipStart = Math.max(0, raw.length - contextLines);
+				linesToShow = raw.slice(skipStart);
+			}
+			if (!nextPartIsChange && linesToShow.length > contextLines) {
+				skipEnd = linesToShow.length - contextLines;
+				linesToShow = linesToShow.slice(0, contextLines);
+			}
+
+			if (skipStart > 0) {
+				output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+				oldLineNum += skipStart;
+				newLineNum += skipStart;
+			}
+			for (const line of linesToShow) {
+				output.push(` ${String(oldLineNum).padStart(lineNumWidth, " ")} ${line}`);
+				oldLineNum++;
+				newLineNum++;
+			}
+			if (skipEnd > 0) {
+				output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+				oldLineNum += skipEnd;
+				newLineNum += skipEnd;
+			}
+		} else {
+			oldLineNum += raw.length;
+			newLineNum += raw.length;
+		}
+		lastWasChange = false;
+	}
+
+	return { diff: output.join("\n"), firstChangedLine };
+}
+
+/**
+ * Generate a compact diff for single-line edits, or fall back to the full diff.
+ *
+ * - Single-line replacement: `LINE:HASH|old → LINE:HASH|new`
+ * - Single-line deletion: `LINE:HASH|old → [deleted]`
+ * - Multi-line changes: full output from generateDiffString()
+ */
+export function generateCompactOrFullDiff(
+	oldContent: string,
+	newContent: string,
+	contextLines = 4,
+): { diff: string; firstChangedLine: number | undefined } {
+	if (oldContent === newContent) return { diff: "", firstChangedLine: undefined };
+
+	const oldLines = oldContent.split("\n");
+	const newLines = newContent.split("\n");
+
+	// Case 1: Same line count, exactly one changed line → compact replacement.
+	if (oldLines.length === newLines.length) {
+		let changedIndex = -1;
+		let changeCount = 0;
+
+		for (let i = 0; i < oldLines.length; i++) {
+			if (oldLines[i] !== newLines[i]) {
+				changedIndex = i;
+				changeCount++;
+				if (changeCount > 1) break;
+			}
+		}
+
+		if (changeCount === 1 && changedIndex >= 0) {
+			const lineNum = changedIndex + 1;
+			const oldLine = oldLines[changedIndex] ?? "";
+			const newLine = newLines[changedIndex] ?? "";
+			const oldHash = computeLineHash(lineNum, oldLine);
+			const newHash = computeLineHash(lineNum, newLine);
+			return {
+				diff: `${lineNum}:${oldHash}|${oldLine} → ${lineNum}:${newHash}|${newLine}`,
+				firstChangedLine: lineNum,
+			};
+		}
+	}
+
+	// Case 2: Exactly one line deleted.
+	// old has one more line than new, and removing a single line makes them equal.
+	if (oldLines.length === newLines.length + 1) {
+		let deletedIndex = -1;
+		let j = 0;
+		let failed = false;
+
+		for (let i = 0; i < oldLines.length; i++) {
+			if (j < newLines.length && oldLines[i] === newLines[j]) {
+				j++;
+				continue;
+			}
+			if (deletedIndex === -1) {
+				deletedIndex = i;
+				continue;
+			}
+			failed = true;
+			break;
+		}
+
+		if (!failed && deletedIndex !== -1 && j === newLines.length) {
+			const lineNum = deletedIndex + 1;
+			const oldLine = oldLines[deletedIndex] ?? "";
+			const oldHash = computeLineHash(lineNum, oldLine);
+			return {
+				diff: `${lineNum}:${oldHash}|${oldLine} → [deleted]`,
+				firstChangedLine: lineNum,
+			};
+		}
+	}
+
+	// Fall back to the full (existing) diff format.
+	return generateDiffString(oldContent, newContent, contextLines);
+}

package/src/edit-output.ts

@@ -0,0 +1,107 @@
+import { countEditTypes, parseDiffStats } from "./edit-render-helpers.js";
+import { buildReadseekEditResult, type SemanticSummary } from "./readseek-value.js";
+import { buildContextHygieneMetadata, buildFileResource, type ContextHygieneMetadata } from "./context-hygiene.js";
+import type { DiffData } from "./diff-data.js";
+export interface BuildEditOutputInput {
+  path: string;
+  displayPath: string;
+  diff: string;
+  patch?: string;
+  diffData?: DiffData;
+  firstChangedLine: number | undefined;
+  warnings: string[];
+  noopEdits: unknown[];
+  semanticSummary?: SemanticSummary;
+  edits?: unknown[];
+}
+export interface EditOutputResult {
+  text: string;
+  patch: string;
+  readseekValue: ReturnType<typeof buildReadseekEditResult>;
+  contextHygiene: ContextHygieneMetadata;
+}
+function getVisibleDiffStats(diff: string): { added: number; removed: number } {
+  const stats = parseDiffStats(diff);
+  if (stats.added > 0 || stats.removed > 0) return stats;
+  if (!diff.includes("→")) return stats;
+  if (diff.includes("→ [deleted]")) return { added: 0, removed: 1 };
+  return { added: 1, removed: 1 };
+}
+function buildVisibleSummary(displayPath: string, diff: string, edits: unknown[] | undefined): string {
+  let stats = getVisibleDiffStats(diff);
+  const counts = countEditTypes(edits);
+  const editCount = counts.total || 1;
+
+  if (
+    counts.total > 0 &&
+    counts.insert_after === counts.total &&
+    stats.removed > 0 &&
+    stats.added === stats.removed + counts.insert_after
+  ) {
+    stats = { added: counts.insert_after, removed: 0 };
+  }
+
+  const changeWord = editCount === 1 ? "change" : "changes";
+  const changedLineCount = Math.max(stats.added, stats.removed);
+  const lineWord = changedLineCount === 1 ? "line" : "lines";
+  return `Edited ${displayPath} (${editCount} ${changeWord}, +${stats.added} -${stats.removed} ${lineWord})`;
+}
+function extractNewTextValues(edits: unknown[] | undefined): string[] {
+  const values: string[] = [];
+  for (const edit of edits ?? []) {
+    if (!edit || typeof edit !== "object") continue;
+    if ("set_line" in edit && typeof (edit as any).set_line?.new_text === "string") values.push((edit as any).set_line.new_text);
+    if ("replace_lines" in edit && typeof (edit as any).replace_lines?.new_text === "string") values.push((edit as any).replace_lines.new_text);
+    if ("insert_after" in edit && typeof (edit as any).insert_after?.new_text === "string") values.push((edit as any).insert_after.new_text);
+    if ("replace" in edit && typeof (edit as any).replace?.new_text === "string") values.push((edit as any).replace.new_text);
+  }
+  return values;
+}
+function formatWhitespaceOnlyWarning(semanticSummary: SemanticSummary | undefined, edits: unknown[] | undefined): string | undefined {
+  if (semanticSummary?.classification !== "whitespace-only") return undefined;
+  if (!extractNewTextValues(edits).some((text) => /\S/.test(text))) return undefined;
+  return "⚠ Edit classified as whitespace-only — if you intended a behavior change, re-read to verify.";
+}
+function formatSemanticSuffix(semanticSummary: SemanticSummary | undefined): string {
+  const movedBlocks = semanticSummary?.movedBlocks ?? 0;
+  if (movedBlocks <= 0) return "";
+  const blockWord = movedBlocks === 1 ? "block" : "blocks";
+  return ` [semantic: ${semanticSummary!.classification}, ${movedBlocks} ${blockWord} moved]`;
+}
+function formatReplaceHint(edits: unknown[] | undefined, noopEdits: unknown[]): string | undefined {
+  if ((noopEdits ?? []).length > 0) return undefined;
+  const counts = countEditTypes(edits);
+  if (counts.replace === 0) return undefined;
+  if (counts.replace !== counts.total) return undefined;
+  return "[info: this edit used replace (unverified). For safer future edits, prefer set_line/replace_lines with an anchor from read/grep/search.]";
+}
+export function buildEditOutput(input: BuildEditOutputInput): EditOutputResult {
+  const summary = `Updated ${input.displayPath}`;
+  const visibleSummary = `${buildVisibleSummary(input.displayPath, input.diff, input.edits)}${formatSemanticSuffix(input.semanticSummary)}`;
+  const semanticWarning = formatWhitespaceOnlyWarning(input.semanticSummary, input.edits);
+  const warningText = input.warnings.length ? `\n\nWarnings:\n${input.warnings.join("\n")}` : "";
+  const replaceHint = formatReplaceHint(input.edits, input.noopEdits);
+  let text = visibleSummary;
+  if (semanticWarning) text += `\n${semanticWarning}`;
+  text += warningText;
+  if (replaceHint) text += `\n${replaceHint}`;
+  return {
+    text,
+    patch: input.patch ?? "",
+    readseekValue: buildReadseekEditResult({
+      path: input.path,
+      summary,
+      diff: input.diff,
+      ...(input.diffData ? { diffData: input.diffData } : {}),
+      firstChangedLine: input.firstChangedLine,
+      warnings: input.warnings,
+      noopEdits: input.noopEdits,
+      ...(input.semanticSummary ? { semanticSummary: input.semanticSummary } : {}),
+    }),
+    contextHygiene: buildContextHygieneMetadata({
+      tool: "edit",
+      classification: "mutation",
+      resources: [buildFileResource(input.path)],
+    }),
+  };
+}