@kr78/pi-coding-agent 17.2.10

package/src/edit/edit-clipboard.ts

@@ -0,0 +1,23 @@
+/**
+ * Session-bound edit clipboard register.
+ *
+ * `CUT`/`PASTE` hashline ops share one {@link Clipboard} per session so
+ * content captured by one edit call can be pasted by a later one (and across
+ * files within one call). The executor works on a fork per batch and commits
+ * it back only after every write lands — see `executeHashlineSingle`.
+ */
+import type { Clipboard } from "@oh-my-pi/hashline";
+
+interface EditClipboardOwner {
+	editClipboard?: Clipboard;
+}
+
+/**
+ * Look up (or lazily create) the clipboard register attached to a session.
+ * Storage lives on `session.editClipboard` so it ages out exactly with the
+ * session itself.
+ */
+export function getEditClipboard(session: EditClipboardOwner): Clipboard {
+	session.editClipboard ??= {};
+	return session.editClipboard;
+}

package/src/edit/file-snapshot-store.ts

@@ -0,0 +1,148 @@
+/**
+ * Session-bound file snapshot store.
+ *
+ * Used by `read` and `search` to record exactly what the model saw, and by
+ * the hashline patcher to verify or recover from stale section tags (file
+ * changed externally between read and edit, or a prior in-session edit
+ * advanced the tag). The store is the {@link InMemorySnapshotStore}
+ * from `@oh-my-pi/hashline`; the only coding-agent-specific concern here
+ * is wiring it onto the per-session owner object.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { InMemorySnapshotStore } from "@oh-my-pi/hashline";
+import { normalizeToLF } from "./normalize";
+
+/**
+ * Upper bound on the file size we snapshot. A section tag is a content hash of
+ * the *whole* file, so minting one means holding the full normalized text in
+ * the store. Files above this cap emit no `[path#tag]` header — line-anchored
+ * editing of multi-megabyte files is out of scope under the full-content model.
+ */
+export const SNAPSHOT_MAX_BYTES = 4 * 1024 * 1024;
+
+interface FileSnapshotStoreOwner {
+	fileSnapshotStore?: InMemorySnapshotStore;
+}
+
+/**
+ * Look up (or lazily create) the file snapshot store attached to a session.
+ * Storage lives on `session.fileSnapshotStore` so it ages out exactly with
+ * the session itself.
+ */
+export function getFileSnapshotStore(session: FileSnapshotStoreOwner): InMemorySnapshotStore {
+	if (!session.fileSnapshotStore) session.fileSnapshotStore = new InMemorySnapshotStore();
+	return session.fileSnapshotStore;
+}
+
+/**
+ * Canonicalize an absolute path into the stable key the snapshot store uses.
+ *
+ * Different code paths reach the snapshot store via different path forms:
+ * `read local://foo.md` records under the file's `fs.realpath` (the local
+ * protocol handler resolves symlinks); a subsequent `edit` may address the
+ * same artifact via `local://foo.md`, whose resolver does NOT realpath, or
+ * via the absolute path returned in the `[path#tag]` header. macOS adds the
+ * same hazard at the working-tree level (`/tmp/...` vs `/private/tmp/...`).
+ * Collapsing every key through `realpath` makes those forms fuse onto one
+ * snapshot entry, so a freshly-minted tag is never rejected as stale just
+ * because the lookup spelled the same file differently.
+ *
+ * Non-existent paths (new-file writes) fall back to a realpath of the parent
+ * directory + basename, then to the input. This keeps creates and updates on
+ * the same canonical key.
+ */
+export function canonicalSnapshotKey(absolutePath: string): string {
+	try {
+		return fs.realpathSync.native(absolutePath);
+	} catch {
+		try {
+			const parent = fs.realpathSync.native(path.dirname(absolutePath));
+			return path.join(parent, path.basename(absolutePath));
+		} catch {
+			return absolutePath;
+		}
+	}
+}
+
+/**
+ * Read the full text of `absolutePath` (within {@link SNAPSHOT_MAX_BYTES}),
+ * record it as a version snapshot, and return its content-hash tag. Returns
+ * `undefined` when the file exceeds the cap or cannot be read — callers then
+ * omit the section header so the model never sees a tag it can't anchor against.
+ *
+ * Producers that only displayed a slice of the file (range reads, search hits)
+ * use this to mint a whole-file tag: the displayed lines stay partial, but the
+ * tag fingerprints the entire file so a follow-up edit anchored at any line
+ * validates whenever the live file is byte-identical to what was read. Raw
+ * reads pass `seenLines` even though they do not emit a header, letting a prior
+ * or later same-content hashline tag inherit the raw range's provenance.
+ */
+export async function recordFileSnapshot(
+	session: FileSnapshotStoreOwner,
+	absolutePath: string,
+	seenLines?: Iterable<number>,
+): Promise<string | undefined> {
+	try {
+		const file = Bun.file(absolutePath);
+		if (file.size > SNAPSHOT_MAX_BYTES) return undefined;
+		const normalized = normalizeToLF(await file.text());
+		return getFileSnapshotStore(session).record(canonicalSnapshotKey(absolutePath), normalized, seenLines);
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Leading line-number prefix the hashline/summary/grep formatters stamp on
+ * every displayed body line: `NN:` or a collapsed summary `NN-MM:` from `read`,
+ * optionally preceded by a grep `*` (match) / space (context) marker from
+ * `search`/`ast-grep`. Anchored at line start, so source content after the
+ * colon never matches.
+ */
+const HASHLINE_LINE_PREFIX = /^[ *]?(\d+)(?:-(\d+))?:/;
+
+/**
+ * The 1-indexed file lines a hashline-formatted body actually displayed.
+ * Single `NN:` rows contribute that line; a collapsed summary `NN-MM:` row
+ * (a `{ … }` brace pair) contributes only its boundary lines `NN` and `MM` —
+ * the elided interior was never shown, so editing inside it must be rejected.
+ */
+export function parseSeenLinesFromHashlineBody(body: string): number[] {
+	const seen: number[] = [];
+	for (const row of body.split("\n")) {
+		const match = HASHLINE_LINE_PREFIX.exec(row);
+		if (!match) continue;
+		seen.push(Number(match[1]));
+		if (match[2] !== undefined) seen.push(Number(match[2]));
+	}
+	return seen;
+}
+
+/** Merge explicit 1-indexed displayed lines into a recorded hashline snapshot. */
+export function recordSeenLines(
+	session: FileSnapshotStoreOwner,
+	absolutePath: string,
+	tag: string,
+	lines: readonly number[],
+): void {
+	if (lines.length === 0) return;
+	getFileSnapshotStore(session).recordSeenLines(canonicalSnapshotKey(absolutePath), tag, lines);
+}
+
+/**
+ * Attach the lines a read displayed to the snapshot it minted, so the patcher's
+ * (opt-in) seen-line guard can reject edits anchored on lines the model never
+ * saw. Best-effort: a no-op when the body has no numbered rows or the snapshot
+ * already aged out. `tag` must be the tag returned when this exact content was
+ * recorded. Every displayed `NN:` row counts as seen, including column-clipped
+ * rows — the guard no longer distinguishes full-width from truncated display.
+ */
+export function recordSeenLinesFromBody(
+	session: FileSnapshotStoreOwner,
+	absolutePath: string,
+	tag: string,
+	body: string,
+): void {
+	recordSeenLines(session, absolutePath, tag, parseSeenLinesFromHashlineBody(body));
+}

package/src/edit/hashline/block-resolver.ts

@@ -0,0 +1,33 @@
+/**
+ * Tree-sitter-backed {@link BlockResolver} for the hashline `N*` locator.
+ * Bridges the pure hashline seam to the native `blockRangeAt` primitive in
+ * `@oh-my-pi/pi-natives`, which infers the language from the file path and
+ * returns the 1-indexed line span of the syntactic block beginning on the
+ * requested line (or `null` when none can be resolved).
+ */
+import type { BlockResolver } from "@oh-my-pi/hashline";
+import { blockRangeAt } from "@oh-my-pi/pi-natives";
+
+/**
+ * `blockRangeAt` runs a full synchronous tree-sitter parse of `text` per
+ * call, and streaming previews re-resolve the same (text, line) every
+ * streamed chunk. Memoize by content: identical text + line always yields the
+ * same span. FIFO-bounded; hashing the text is orders of magnitude cheaper
+ * than re-parsing it.
+ */
+const resolutionCache = new Map<string, { start: number; end: number } | null>();
+const RESOLUTION_CACHE_MAX = 512;
+
+export const nativeBlockResolver: BlockResolver = ({ path, text, line }) => {
+	const key = `${Bun.hash(text).toString(36)}:${text.length}:${line}:${path}`;
+	const cached = resolutionCache.get(key);
+	if (cached !== undefined) return cached;
+	const range = blockRangeAt({ code: text, path, line });
+	const result = range ? { start: range.startLine, end: range.endLine } : null;
+	if (resolutionCache.size >= RESOLUTION_CACHE_MAX) {
+		const oldest = resolutionCache.keys().next().value;
+		if (oldest !== undefined) resolutionCache.delete(oldest);
+	}
+	resolutionCache.set(key, result);
+	return result;
+};

package/src/edit/hashline/diff.ts

@@ -0,0 +1,402 @@
+/**
+ * Read-only hashline diff preview helpers used by the streaming edit
+ * renderer. Reads the target file, parses + applies the section's edits in
+ * memory (no FS write, no LSP writethrough), then hands the before/after
+ * pair to {@link generateDiffString} so the renderer can show the diff
+ * while the tool call is still streaming.
+ *
+ * Uses the same snapshot-tag semantics as the apply path: a live content-hash
+ * match is accepted even when the tag was minted by a source that did not keep
+ * history, and stale tags recover through the session snapshot store when possible.
+ */
+import * as path from "node:path";
+import {
+	type ApplyResult,
+	applyEdits,
+	type Clipboard,
+	type Cursor,
+	computeFileHash,
+	type Edit,
+	forkClipboard,
+	Patch as HashlinePatch,
+	hasBlockEdit,
+	MismatchError,
+	missingSnapshotTagMessage,
+	normalizeToLF,
+	type Patch,
+	type PatchSection,
+	parsePatchStreaming,
+	Recovery,
+	resolveBlockEdits,
+	resolveClipboardEdits,
+	type SnapshotStore,
+	stripBom,
+	validateClipboardSequence,
+} from "@oh-my-pi/hashline";
+import { resolveToCwd } from "../../tools/path-utils";
+import { generateDiffString } from "../diff";
+import { canonicalSnapshotKey } from "../file-snapshot-store";
+import { readEditFileText } from "../read-file";
+import { nativeBlockResolver } from "./block-resolver";
+
+export interface HashlineDiffOptions {
+	/**
+	 * Use the streaming-tolerant applier ({@link PatchSection.applyPartialTo})
+	 * so trailing in-flight ops do not throw or emit phantom edits. Streaming
+	 * preview path only.
+	 */
+	streaming?: boolean;
+	/**
+	 * Skip snapshot-tag validation. Streaming previews use this so transient
+	 * stale/missing tags do not flash re-read errors while the model is still
+	 * authoring input; the final apply path still validates through Patcher.
+	 */
+	skipHashValidation?: boolean;
+	/**
+	 * Clipboard register shared across the sections of one patch preview.
+	 * `CUT` in an earlier section feeds a register-backed `PUT` in a later one,
+	 * so the preview matches apply. Multi-section previews MUST thread one
+	 * register through sections in patch order; omitted, each section gets a
+	 * private register (same-file cut/put still previews correctly).
+	 */
+	clipboard?: Clipboard;
+}
+
+async function readSectionText(absolutePath: string, sectionPath: string): Promise<string> {
+	try {
+		return await readEditFileText(absolutePath, sectionPath);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(message || `Unable to read ${sectionPath}`);
+	}
+}
+
+/**
+ * Streaming previews recompute on every streamed chunk; re-reading the target
+ * file from disk each tick dominates the cost on large files. Cache the raw
+ * section text keyed by mtime+size so any on-disk change invalidates
+ * naturally. Used by the streaming path only — the args-complete pass always
+ * reads fresh.
+ */
+const streamingTextCache = new Map<string, { mtimeMs: number; size: number; rawContent: string }>();
+const STREAMING_TEXT_CACHE_MAX = 8;
+
+async function readSectionTextCached(absolutePath: string, sectionPath: string): Promise<string> {
+	let stamp: { mtimeMs: number; size: number } | undefined;
+	try {
+		const stat = await Bun.file(absolutePath).stat();
+		stamp = { mtimeMs: stat.mtimeMs, size: stat.size };
+	} catch {
+		stamp = undefined;
+	}
+	if (stamp) {
+		const cached = streamingTextCache.get(absolutePath);
+		if (cached && cached.mtimeMs === stamp.mtimeMs && cached.size === stamp.size) return cached.rawContent;
+	}
+	const rawContent = await readSectionText(absolutePath, sectionPath);
+	if (stamp) {
+		if (streamingTextCache.size >= STREAMING_TEXT_CACHE_MAX && !streamingTextCache.has(absolutePath)) {
+			const oldest = streamingTextCache.keys().next().value;
+			if (oldest !== undefined) streamingTextCache.delete(oldest);
+		}
+		streamingTextCache.set(absolutePath, { mtimeMs: stamp.mtimeMs, size: stamp.size, rawContent });
+	}
+	return rawContent;
+}
+
+/**
+ * Resolve a missing authored path to a file read this session by matching its
+ * basename and snapshot tag, mirroring {@link Patcher}'s apply-time recovery so
+ * a bare/wrong-directory `[basename#tag]` header previews against the same file
+ * the edit will land on. Returns `undefined` when no unique basename+tag match
+ * exists, leaving the caller to surface the original read error.
+ */
+function recoverSectionPathFromTag(
+	section: PatchSection,
+	authoredAbsolutePath: string,
+	snapshots: SnapshotStore,
+): string | undefined {
+	if (section.fileHash === undefined) return undefined;
+	const authoredName = path.basename(section.path);
+	const authoredKey = canonicalSnapshotKey(authoredAbsolutePath);
+	const candidates = [
+		...new Set(
+			snapshots
+				.findByHash(section.fileHash)
+				.filter(snapshot => path.basename(snapshot.path) === authoredName)
+				.map(snapshot => snapshot.path),
+		),
+	].filter(candidate => candidate !== authoredKey);
+	return candidates.length === 1 ? candidates[0] : undefined;
+}
+
+/**
+ * Read the section's target file for a preview, recovering a bare/mis-typed
+ * `[basename#tag]` path onto the file its tag uniquely names. Recovery fires
+ * only when the authored path is absent — matching {@link Patcher}'s apply-time
+ * order — so a permission/parse error on an existing file surfaces against the
+ * authored path instead of silently previewing a different tagged file. Returns
+ * the path actually read so callers key snapshot lookups off the same file.
+ */
+async function readSectionForPreview(
+	section: PatchSection,
+	authoredAbsolutePath: string,
+	snapshots: SnapshotStore,
+	streaming: boolean | undefined,
+): Promise<{ absolutePath: string; rawContent: string }> {
+	const read = streaming ? readSectionTextCached : readSectionText;
+	const recovered = (await Bun.file(authoredAbsolutePath).exists())
+		? undefined
+		: recoverSectionPathFromTag(section, authoredAbsolutePath, snapshots);
+	const target = recovered ?? authoredAbsolutePath;
+	return { absolutePath: target, rawContent: await read(target, section.path) };
+}
+
+function hasAnchorScopedEdit(edits: readonly Edit[]): boolean {
+	return edits.some(edit => {
+		if (edit.kind === "delete" || edit.kind === "block" || edit.kind === "cut") return true;
+		if (edit.kind === "paste") {
+			if (edit.at.kind === "span") return true;
+			return edit.at.cursor.kind === "before_anchor" || edit.at.cursor.kind === "after_anchor";
+		}
+		return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
+	});
+}
+
+function createMismatchError(
+	section: PatchSection,
+	absolutePath: string,
+	normalized: string,
+	snapshots: SnapshotStore,
+	expected: string,
+): MismatchError {
+	return new MismatchError({
+		path: section.path,
+		expectedFileHash: expected,
+		actualFileHash: computeFileHash(normalized),
+		fileLines: normalized.split("\n"),
+		anchorLines: section.collectAnchorLines(),
+		hashRecognized: snapshots.byHash(absolutePath, expected) !== null,
+	});
+}
+
+function parsePreviewEdits(section: PatchSection, streaming: boolean | undefined): readonly Edit[] {
+	return streaming ? parsePatchStreaming(section.diff).edits : section.edits;
+}
+
+function resolvePreviewEdits(args: {
+	section: PatchSection;
+	absolutePath: string;
+	normalized: string;
+	snapshots: SnapshotStore;
+	expected: string | undefined;
+	liveMatches: boolean;
+	edits: readonly Edit[];
+}): readonly Edit[] {
+	const { section, absolutePath, normalized, snapshots, expected, liveMatches, edits } = args;
+	if (!hasBlockEdit(edits)) return edits;
+	const baseText = expected === undefined || liveMatches ? normalized : snapshots.byHash(absolutePath, expected)?.text;
+	if (baseText === undefined) {
+		throw createMismatchError(section, absolutePath, normalized, snapshots, expected ?? "");
+	}
+	return resolveBlockEdits(edits, baseText, section.path, nativeBlockResolver, { onUnresolved: "throw" });
+}
+
+function applyPreviewEdits(args: {
+	section: PatchSection;
+	absolutePath: string;
+	normalized: string;
+	snapshots: SnapshotStore;
+	options: HashlineDiffOptions;
+}): ApplyResult {
+	const { section, absolutePath, normalized, snapshots, options } = args;
+	const expected = section.fileHash;
+	if (!options.skipHashValidation && expected === undefined) {
+		throw new Error(missingSnapshotTagMessage(section.path));
+	}
+	// The 4-hex tag is content-derived: when the live text hashes to it, trust
+	// the match and preview directly (mirrors Patcher's apply-time behavior).
+	const liveMatches = expected !== undefined && computeFileHash(normalized) === expected;
+	const edits = parsePreviewEdits(section, options.streaming);
+	const resolved = resolvePreviewEdits({ section, absolutePath, normalized, snapshots, expected, liveMatches, edits });
+	const clipboard = options.clipboard ?? {};
+	// Mirror the Patcher: surface clipboard sequencing mistakes with their
+	// targeted message before the recovery path below swallows them. Streaming
+	// previews stay lenient — a mid-typed op transiently violating sequencing
+	// must not flash an error frame.
+	if (!options.streaming) validateClipboardSequence(resolved, clipboard);
+	const applyOptions = { clipboard, ...(options.streaming ? { onEmptyPaste: "drop" as const } : {}) };
+	if (options.skipHashValidation || expected === undefined || liveMatches) {
+		return applyEdits(normalized, resolved, applyOptions);
+	}
+	if (!hasAnchorScopedEdit(resolved)) return applyEdits(normalized, resolved, applyOptions);
+
+	const recovered = new Recovery(snapshots).tryRecover({
+		path: absolutePath,
+		currentText: normalized,
+		fileHash: expected,
+		edits: resolved,
+		clipboard,
+	});
+	if (recovered) return recovered;
+	throw createMismatchError(section, absolutePath, normalized, snapshots, expected);
+}
+
+/**
+ * Map an insert cursor to the 1-indexed line where its payload lands, used to
+ * number the `+` rows of a streaming preview. Deliberately approximate: it
+ * ignores line shifts introduced by sibling ops, because the args-complete
+ * pass renumbers everything through the real unified diff.
+ */
+function insertCursorLine(cursor: Cursor, fileLineCount: number): number {
+	switch (cursor.kind) {
+		case "bof":
+			return 1;
+		case "eof":
+			return fileLineCount + 1;
+		case "before_anchor":
+			return cursor.anchor.line;
+		case "after_anchor":
+			return cursor.anchor.line + 1;
+	}
+}
+
+/**
+ * Build a streaming diff preview by emitting, per op in patch order, the
+ * removed file lines followed by the op's `+` payload rows — never a whole-file
+ * Myers re-diff. {@link generateDiffString} re-aligns the in-flight payload
+ * against the removed block on every streamed chunk (it greedily matches shared
+ * `}`/blank/`return` rows), so additions jump between hunks and the tail window
+ * the renderer pins stutters tick to tick. Natural order keeps the removed
+ * block fixed and grows the payload monotonically at the bottom so the streamed
+ * cursor stays put. Mirrors the apply_patch streaming strategy; the
+ * args-complete pass still produces the real unified diff.
+ */
+function buildStreamingSectionDiff(
+	section: PatchSection,
+	normalized: string,
+	clipboard: Clipboard,
+): { diff: string; firstChangedLine: number | undefined } | { error: string } {
+	const { edits, fileOp } = parsePatchStreaming(section.diff);
+	const blockResolved = resolveBlockEdits(edits, normalized, section.path, nativeBlockResolver, {
+		onUnresolved: "drop",
+	});
+	const fileLines = normalized.split("\n");
+	// Expand register-backed PUT ops so moved rows appear in the preview.
+	// Resolve into a transactional register and publish it only on success: a
+	// mid-typed capture (out-of-range while the range digits are still
+	// streaming, transient sequencing violations) throws AFTER earlier
+	// captures may have landed, and leaking those into the shared register
+	// would let a later section preview a PUT that never happened. On failure,
+	// filter the clipboard edits out of this section's frame.
+	const scratch = forkClipboard(clipboard);
+	let resolved: readonly Edit[];
+	try {
+		resolved = resolveClipboardEdits(blockResolved, fileLines, scratch, { onEmptyPaste: "drop" });
+		if (scratch.lines === undefined) delete clipboard.lines;
+		else clipboard.lines = scratch.lines;
+		if (scratch.named === undefined) delete clipboard.named;
+		else clipboard.named = scratch.named;
+		if (scratch.pendingAnonCuts === undefined) delete clipboard.pendingAnonCuts;
+		else clipboard.pendingAnonCuts = scratch.pendingAnonCuts;
+	} catch {
+		resolved = blockResolved.filter(edit => edit.kind !== "cut" && edit.kind !== "paste");
+	}
+	if (resolved.length === 0) {
+		// A whole-file op (REM / MV) carries no line edits; the result header
+		// conveys the change, so emit an empty diff.
+		if (fileOp) return { diff: "", firstChangedLine: undefined };
+		return { error: `No changes would be made to ${section.path}.` };
+	}
+
+	const rows: string[] = [];
+	let firstChangedLine: number | undefined;
+
+	// Every edit emitted from one op header carries that header's patch line
+	// number and the edits sit contiguously (a replace lays down its replacement
+	// inserts then its range deletes; block ops expand to the same shape). Group
+	// on that boundary so each op stays intact and ordered.
+	for (let i = 0; i < resolved.length; ) {
+		const opLine = resolved[i].lineNum;
+		const deletes: number[] = [];
+		const inserts: string[] = [];
+		let insertBase: number | undefined;
+		while (i < resolved.length && resolved[i].lineNum === opLine) {
+			const edit = resolved[i];
+			if (edit.kind === "delete") deletes.push(edit.anchor.line);
+			else if (edit.kind === "insert") {
+				insertBase ??= insertCursorLine(edit.cursor, fileLines.length);
+				inserts.push(edit.text);
+			}
+			i++;
+		}
+		// Removed lines first (a fixed block), payload second (grows at the
+		// bottom = the streamed cursor).
+		deletes.sort((a, b) => a - b);
+		for (const line of deletes) {
+			firstChangedLine ??= line;
+			const content = line >= 1 && line <= fileLines.length ? fileLines[line - 1] : "";
+			rows.push(`-${line}|${content}`);
+		}
+		let newLine = insertBase ?? deletes[0] ?? 1;
+		for (const text of inserts) {
+			firstChangedLine ??= newLine;
+			rows.push(`+${newLine}|${text}`);
+			newLine++;
+		}
+	}
+
+	if (rows.length === 0) return { error: `No changes would be made to ${section.path}.` };
+	return { diff: rows.join("\n"), firstChangedLine };
+}
+
+export async function computeHashlineSectionDiff(
+	section: PatchSection,
+	cwd: string,
+	snapshots: SnapshotStore,
+	options: HashlineDiffOptions = {},
+): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
+	try {
+		const authoredPath = resolveToCwd(section.path, cwd);
+		const { absolutePath, rawContent } = await readSectionForPreview(
+			section,
+			authoredPath,
+			snapshots,
+			options.streaming,
+		);
+		const { text: content } = stripBom(rawContent);
+		const normalized = normalizeToLF(content);
+		// Streaming favors a stable, monotonic preview over an exact unified
+		// diff: feed the in-flight ops through the natural-order builder so the
+		// streamed cursor stays pinned to the bottom. The args-complete pass
+		// (`streaming` unset) falls through to the real Myers diff below.
+		if (options.streaming) return buildStreamingSectionDiff(section, normalized, options.clipboard ?? {});
+		const result = applyPreviewEdits({ section, absolutePath, normalized, snapshots, options });
+		if (normalized === result.text) {
+			// REM/MV-only sections change no text; the header conveys the op.
+			if (section.fileOp) return { diff: "", firstChangedLine: undefined };
+			return { error: `No changes would be made to ${section.path}.` };
+		}
+		return generateDiffString(normalized, result.text, undefined, { path: section.path });
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+}
+
+export async function computeHashlineDiff(
+	input: { input: string },
+	cwd: string,
+	snapshots: SnapshotStore,
+	options: HashlineDiffOptions = {},
+): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
+	let patch: Patch;
+	try {
+		patch = HashlinePatch.parse(input.input, { cwd });
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+	if (patch.sections.length !== 1) {
+		return { error: "Streaming diff preview supports exactly one hashline section." };
+	}
+	return computeHashlineSectionDiff(patch.sections[0], cwd, snapshots, options);
+}