@d3ara1n/pi-hashline-edit 0.1.0 → 0.1.2

package/src/pi/execute.test.ts

@@ -1,6 +1,7 @@
 /**
- * pi 接入层 execute 集成测试：驱动真实的 makeReadOverride/makeEditOverride
- * execute，覆盖文本 read 带锚、hashline edit 闭环、错误返回 isError。
+ * pi integration execute tests: drive the real makeReadOverride/makeEditOverride
+ * execute, covering text read with anchors, the hashline edit round-trip,
+ * chained edits via returned anchors, and error returns with isError.
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
@@ -9,26 +10,36 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { makeEditOverride } from "./edit-tool.ts";
 import { makeReadOverride } from "./read-tool.ts";
-import { clearSnapshots, getSnapshot } from "./state.ts";
+import { computeLineHash } from "../core/hash.ts";
+import { splitLines } from "../core/lines.ts";
 
 async function withDir<T>(fn: (dir: string) => Promise<T>): Promise<T> {
 	const dir = await mkdtemp(join(tmpdir(), "hl-"));
-	clearSnapshots();
 	try {
 		return await fn(dir);
 	} finally {
 		await rm(dir, { recursive: true, force: true });
-		clearSnapshots();
 	}
 }
 
 const call = (tool: any, params: any) => tool.execute("0", params, undefined, undefined);
 
-test("read execute：文本输出 LINE#HASH│content", async () => {
+/** Anchor a model would copy from read output for `line` of `text` (1-based). */
+function h(text: string, line: number) {
+	return { line, hash: computeLineHash(line, splitLines(text)[line - 1]) };
+}
+
+/** Extract a `LINE#HASH` anchor from a read/edit result text block. */
+function anchorLine(block: string, line: number) {
+	const m = new RegExp(`^${line}#([0-9A-Z]+)│`, "m").exec(block);
+	if (!m) throw new Error(`line ${line} anchor not found in block`);
+	return { line, hash: m[1] };
+}
+
+test("read execute: text outputs LINE#HASH│content", async () => {
 	await withDir(async (dir) => {
 		await writeFile(join(dir, "f.txt"), "line1\nline2\n");
-		const read = makeReadOverride(dir);
-		const r: any = await call(read, { path: "f.txt" });
+		const r: any = await call(makeReadOverride(dir), { path: "f.txt" });
 		const text = r.content[0];
 		assert.equal(text.type, "text");
 		assert.match(text.text, /1#[0-9A-Z]+│line1/);
@@ -37,88 +48,224 @@ test("read execute：文本输出 LINE#HASH│content", async () => {
 	});
 });
 
-test("read execute：记录 snapshot 供 edit 用", async () => {
+test("edit execute: hashline round-trip (read → edit → file changed)", async () => {
 	await withDir(async (dir) => {
-		await writeFile(join(dir, "f.txt"), "a\nb\n");
-		const read = makeReadOverride(dir);
-		await call(read, { path: "f.txt" });
-		const snap = getSnapshot(join(dir, "f.txt"));
-		assert.ok(snap, "snapshot 未记录");
-		assert.equal(snap!.lineHashes.length, 2);
+		const f = join(dir, "f.txt");
+		const text = "a\nb\nc\n";
+		await writeFile(f, text);
+		await call(makeReadOverride(dir), { path: "f.txt" });
+		const r: any = await call(makeEditOverride(dir), {
+			path: "f.txt",
+			edits: [{ op: "replace", anchor: h(text, 2), body: ["B"] }],
+		});
+		assert.equal(r.isError, undefined, "should not be an error");
+		assert.equal(await readFile(f, "utf-8"), "a\nB\nc\n");
 	});
 });
 
-test("edit execute：hashline 闭环（read → edit → 文件改）", async () => {
+test("edit execute: multiple ops in one call", async () => {
 	await withDir(async (dir) => {
 		const f = join(dir, "f.txt");
-		await writeFile(f, "a\nb\nc\n");
+		const text = "a\nb\nc\n";
+		await writeFile(f, text);
 		await call(makeReadOverride(dir), { path: "f.txt" });
-		const snap = getSnapshot(f)!;
+		const r: any = await call(makeEditOverride(dir), {
+			path: "f.txt",
+			edits: [
+				{ op: "insert_after", anchor: h(text, 3), body: ["z"] },
+				{ op: "replace", anchor: h(text, 1), body: ["A"] },
+			],
+		});
+		assert.equal(r.isError, undefined);
+		assert.equal(await readFile(f, "utf-8"), "A\nb\nc\nz\n");
+	});
+});
+
+test("edit result returns Updated anchors that chain the next edit without a re-read", async () => {
+	await withDir(async (dir) => {
+		const f = join(dir, "f.txt");
+		const text = "a\nb\nc\n";
+		await writeFile(f, text);
 		const edit = makeEditOverride(dir);
-		const r: any = await call(edit, {
+		// first edit (model cites the read anchor for line 1)
+		const r1: any = await call(edit, {
 			path: "f.txt",
-			input: `replace 2#${snap.lineHashes[1]}:\n+B`,
+			edits: [{ op: "replace", anchor: h(text, 1), body: ["A"] }],
 		});
-		assert.equal(r.isError, undefined, "不应是错误");
-		assert.equal(await readFile(f, "utf-8"), "a\nB\nc\n");
+		assert.equal(r1.isError, undefined);
+		const out: string = r1.content[0].text;
+		assert.match(out, /Updated anchors/);
+		// second edit chains on the anchor returned by the first edit — no read in between
+		const r2: any = await call(edit, {
+			path: "f.txt",
+			edits: [{ op: "replace", anchor: anchorLine(out, 1), body: ["AA"] }],
+		});
+		assert.equal(r2.isError, undefined);
+		assert.equal(await readFile(f, "utf-8"), "AA\nb\nc\n");
 	});
 });
 
-test("edit execute：连续 edit 复用更新后的 snapshot", async () => {
+test("edit result anchors cover an inserted block (chain an edit inside it)", async () => {
 	await withDir(async (dir) => {
 		const f = join(dir, "f.txt");
-		await writeFile(f, "a\nb\n");
-		const read = makeReadOverride(dir);
+		const text = "a\nb\n";
+		await writeFile(f, text);
 		const edit = makeEditOverride(dir);
-		await call(read, { path: "f.txt" });
-		let snap = getSnapshot(f)!;
-		await call(edit, { path: "f.txt", input: `replace 1#${snap.lineHashes[0]}:\n+A` });
-		// 第二次 edit：snapshot 已被 edit 更新，用新 hash
-		snap = getSnapshot(f)!;
-		const r: any = await call(edit, { path: "f.txt", input: `replace 2#${snap.lineHashes[1]}:\n+B` });
+		const r1: any = await call(edit, {
+			path: "f.txt",
+			edits: [{ op: "insert_after", anchor: h(text, 2), body: ["c", "d", "e"] }],
+		});
+		assert.equal(r1.isError, undefined);
+		const out: string = r1.content[0].text;
+		// line 4 (d, one of the inserted lines) must be anchored in the result
+		const a4 = anchorLine(out, 4);
+		const r2: any = await call(edit, {
+			path: "f.txt",
+			edits: [{ op: "replace", anchor: a4, body: ["DD"] }],
+		});
+		assert.equal(r2.isError, undefined);
+		assert.equal(await readFile(f, "utf-8"), "a\nb\nc\nDD\ne\n");
+	});
+});
+
+test("unrelated external change does NOT block an edit on a stable line", async () => {
+	await withDir(async (dir) => {
+		const f = join(dir, "f.txt");
+		const text = "a\nb\nc\n";
+		await writeFile(f, text);
+		// simulate an external change at line 3 between read and edit
+		await writeFile(f, "a\nb\nCHANGED\n");
+		const r: any = await call(makeEditOverride(dir), {
+			path: "f.txt",
+			edits: [{ op: "replace", anchor: h(text, 1), body: ["A"] }],
+		});
 		assert.equal(r.isError, undefined);
-		assert.equal(await readFile(f, "utf-8"), "A\nB\n");
+		assert.equal(await readFile(f, "utf-8"), "A\nb\nCHANGED\n");
+	});
+});
+
+test("edit on a line that changed externally → anchor mismatch", async () => {
+	await withDir(async (dir) => {
+		const f = join(dir, "f.txt");
+		const text = "a\nb\nc\n";
+		await writeFile(f, text);
+		await writeFile(f, "a\nBCHANGED\nc\n"); // line 2 changed
+		const r: any = await call(makeEditOverride(dir), {
+			path: "f.txt",
+			edits: [{ op: "replace", anchor: h(text, 2), body: ["x"] }],
+		});
+		assert.equal(r.isError, true);
+		assert.match(r.content[0].text, /anchor|re-read/i);
 	});
 });
 
-test("edit execute：无 read 直接 edit → anchor 校验失败", async () => {
+test("edit execute: no read before edit → anchor verification fails", async () => {
 	await withDir(async (dir) => {
 		await writeFile(join(dir, "f.txt"), "a\nb\n");
-		const edit = makeEditOverride(dir);
-		// 没 read 过，hash 是瞎写的
-		const r: any = await call(edit, { path: "f.txt", input: "replace 1#XXXX:\n+A" });
+		const r: any = await call(makeEditOverride(dir), {
+			path: "f.txt",
+			edits: [{ op: "replace", anchor: { line: 1, hash: "XXXX" }, body: ["A"] }],
+		});
 		assert.equal(r.isError, true);
 	});
 });
 
-test("edit execute：缺 input → isError + missing 提示", async () => {
+test("edit execute: empty edits → isError", async () => {
 	await withDir(async (dir) => {
 		await writeFile(join(dir, "f.txt"), "a\n");
-		const r: any = await call(makeEditOverride(dir), { path: "f.txt" });
+		const r: any = await call(makeEditOverride(dir), { path: "f.txt", edits: [] });
 		assert.equal(r.isError, true);
-		assert.match(r.content[0].text, /missing/);
+		assert.match(r.content[0].text, /empty|missing/i);
 	});
 });
 
-test("edit execute：旧 oldText/newText → isError + legacy 提示", async () => {
+test("edit execute: malformed op (replace without body) → isError", async () => {
 	await withDir(async (dir) => {
 		await writeFile(join(dir, "f.txt"), "a\n");
 		const r: any = await call(makeEditOverride(dir), {
 			path: "f.txt",
-			edits: [{ oldText: "a", newText: "b" }],
+			edits: [{ op: "replace", anchor: { line: 1, hash: "XX" } }],
 		});
 		assert.equal(r.isError, true);
-		assert.match(r.content[0].text, /legacy/);
-		assert.match(r.content[0].text, /ONLY/);
+		assert.match(r.content[0].text, /body/i);
 	});
 });
 
-test("edit execute：parse 错误 → isError", async () => {
+test("edit execute: delete op", async () => {
 	await withDir(async (dir) => {
-		await writeFile(join(dir, "f.txt"), "a\n");
+		const f = join(dir, "f.txt");
+		const text = "a\nb\nc\n";
+		await writeFile(f, text);
+		await call(makeReadOverride(dir), { path: "f.txt" });
+		const r: any = await call(makeEditOverride(dir), {
+			path: "f.txt",
+			edits: [{ op: "delete", anchor: h(text, 2) }],
+		});
+		assert.equal(r.isError, undefined);
+		assert.equal(await readFile(f, "utf-8"), "a\nc\n");
+	});
+});
+
+// --- renderer regression guards (details.diff must be a string, renderResult must not throw) ---
+
+const stubTheme = { fg: (_k: string, s: string) => s, bold: (s: string) => s };
+
+test("edit success: details.diff is a string (not the generateDiffString object)", async () => {
+	await withDir(async (dir) => {
+		const f = join(dir, "f.txt");
+		const text = "a\nb\nc\n";
+		await writeFile(f, text);
 		await call(makeReadOverride(dir), { path: "f.txt" });
-		const r: any = await call(makeEditOverride(dir), { path: "f.txt", input: "SWAP 1#X:\n+a" });
+		const r: any = await call(makeEditOverride(dir), {
+			path: "f.txt",
+			edits: [{ op: "replace", anchor: h(text, 2), body: ["B"] }],
+		});
+		assert.equal(typeof r.details.diff, "string", "details.diff must be a string");
+		assert.equal(typeof r.details.patch, "string");
+		assert.equal(typeof r.details.firstChangedLine, "number");
+	});
+});
+
+test("edit success: renderResult renders the diff without throwing", async () => {
+	await withDir(async (dir) => {
+		const f = join(dir, "f.txt");
+		const text = "a\nb\nc\n";
+		await writeFile(f, text);
+		const edit = makeEditOverride(dir);
+		const r: any = await call(edit, {
+			path: "f.txt",
+			edits: [{ op: "replace", anchor: h(text, 2), body: ["B"] }],
+		});
+		// @ts-ignore — drive the renderer with a stub theme
+		const comp: any = edit.renderResult({ content: r.content, details: r.details }, { isPartial: false, expanded: true }, stubTheme, { isError: r.isError ?? false });
+		assert.ok(typeof comp?.text === "string");
+		assert.ok(comp.text.includes("B"), "rendered diff should contain the new content");
+	});
+});
+
+test("edit error: renderResult renders the error line without throwing", async () => {
+	await withDir(async (dir) => {
+		await writeFile(join(dir, "f.txt"), "a\n");
+		const edit = makeEditOverride(dir);
+		const r: any = await call(edit, {
+			path: "f.txt",
+			edits: [{ op: "replace", anchor: { line: 1, hash: "XXXX" }, body: ["A"] }],
+		});
 		assert.equal(r.isError, true);
-		assert.match(r.content[0].text, /Parse error|unknown verb/);
+		// @ts-ignore
+		const comp: any = edit.renderResult({ content: r.content, details: r.details }, { isPartial: false, expanded: false }, stubTheme, { isError: r.isError ?? false });
+		assert.ok(typeof comp?.text === "string");
+	});
+});
+
+test("hash length stays 4 even for runs of identical lines (no explosion)", async () => {
+	await withDir(async (dir) => {
+		const f = join(dir, "f.txt");
+		await writeFile(f, "\n\n\n\ncode\n");
+		const r: any = await call(makeReadOverride(dir), { path: "f.txt" });
+		const text: string = r.content[0].text;
+		for (const m of text.matchAll(/\d+#([0-9A-Z]+)│/g)) {
+			assert.equal(m[1].length, 4, `anchor ${m[0]} hash is not 4 chars`);
+		}
 	});
 });

package/src/pi/pi.test.ts

@@ -1,28 +1,9 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import { canonicalPath } from "./read-tool.ts";
-import { missingInputError } from "./edit-tool.ts";
 
-test("canonicalPath resolve 相对/绝对", () => {
+test("canonicalPath resolves relative and absolute", () => {
 	assert.equal(canonicalPath("/cwd", "foo.ts"), "/cwd/foo.ts");
 	assert.equal(canonicalPath("/cwd", "./foo.ts"), "/cwd/foo.ts");
 	assert.equal(canonicalPath("/cwd", "/abs/x.ts"), "/abs/x.ts");
 });
-
-test("missingInputError: edits 数组 → 明确告知不降级", () => {
-	const msg = missingInputError("f.ts", { edits: [{ oldText: "a", newText: "b" }] });
-	assert.ok(msg.includes("legacy"), msg);
-	assert.ok(msg.includes("ONLY"), msg);
-	assert.ok(msg.includes("f.ts"), msg);
-});
-
-test("missingInputError: 顶层 oldText/newText 也识别为旧格式", () => {
-	const msg = missingInputError("f.ts", { oldText: "a", newText: "b" });
-	assert.ok(msg.includes("legacy"));
-});
-
-test("missingInputError: 仅缺 input（非旧格式）", () => {
-	const msg = missingInputError("f.ts", {});
-	assert.ok(msg.includes("missing"));
-	assert.ok(!msg.includes("legacy"));
-});

package/src/pi/read-tool.ts

@@ -1,6 +1,10 @@
 /**
- * Override read：文本文件输出「行号#hash│内容」并记录快照；
- * 非文本（图片/二进制）与读取错误透传内置 read，renderer 自动继承。
+ * Override read: text files output "lineNo#hash│content"; non-text (images /
+ * binary) and read errors delegate to the built-in read.
+ *
+ * Hashes are computed from the current content on the fly — nothing is stored.
+ * The hash is `(line number, content)`, recomputed and checked at edit time, so
+ * no snapshot is needed to verify an anchor later.
  *
  * @module pi-hashline-edit/pi
  */
@@ -8,18 +12,19 @@
 import { createReadTool } from "@earendil-works/pi-coding-agent";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { splitLines } from "../core/snapshot.ts";
-import { getState, getSnapshot, recordSnapshot } from "./state.ts";
+import { hashFileLines } from "../core/hash.ts";
+import { splitLines } from "../core/lines.ts";
+import { getState } from "./state.ts";
 
 const MAX_LINES = 2000;
 const MAX_BYTES = 256 * 1024;
 
-/** canonical path：read/edit 共用，保证 snapshot key 一致。 */
+/** canonical path: shared by read/edit to resolve a file consistently. */
 export function canonicalPath(cwd: string, p: string): string {
 	return resolve(cwd, p);
 }
 
-/** 构造 read override（registerTool 的 ToolDefinition 片段）。 */
+/** Build the read override (a ToolDefinition fragment for registerTool). */
 export function makeReadOverride(cwd: string) {
 	const builtin = createReadTool(cwd);
 
@@ -36,8 +41,7 @@ export function makeReadOverride(cwd: string) {
 		parameters: builtin.parameters,
 
 		async execute(toolCallId: string, params: any, signal: AbortSignal | undefined, onUpdate: any) {
-			// 未启用 → 完全透传内置
-			// 未启用 或 用户已取消 → 透传内置（builtin 自行处理 abort）
+			// Not enabled OR user cancelled → delegate to the built-in (builtin handles abort itself)
 			if (!getState().config.enabled || signal?.aborted) return builtin.execute(toolCallId, params, signal, onUpdate);
 
 			const absPath = canonicalPath(cwd, params.path as string);
@@ -45,19 +49,17 @@ export function makeReadOverride(cwd: string) {
 			try {
 				buf = await readFile(absPath);
 			} catch {
-				// 读取错误 → 透传内置（它有完善的错误信息）
+				// read error → delegate to the built-in (it has polished error messages)
 				return builtin.execute(toolCallId, params, signal, onUpdate);
 			}
 
-			// 二进制/图片检测（null 字节）→ 透传内置（内置用 file-type 处理图片）
+			// binary/image detection (null byte) → delegate to the built-in (it uses file-type for images)
 			if (buf.includes(0)) return builtin.execute(toolCallId, params, signal, onUpdate);
 
 			const text = buf.toString("utf-8");
 			const allLines = splitLines(text);
 			const totalLines = allLines.length;
-
-			// 记录全文快照（edit 锚基于全文行号）
-			const snap = recordSnapshot(absPath, text);
+			const hashes = hashFileLines(allLines, getState().config.hashLen);
 
 			// offset/limit
 			const offset = (params.offset as number | undefined) ?? 1;
@@ -70,7 +72,7 @@ export function makeReadOverride(cwd: string) {
 			let truncated = false;
 			for (let i = startIdx; i < endIdx; i++) {
 				const lineNo = i + 1;
-				const row = `${lineNo}#${snap.lineHashes[i]}│${allLines[i]}`;
+				const row = `${lineNo}#${hashes[i]}│${allLines[i]}`;
 				bytes += Buffer.byteLength(row, "utf-8");
 				if (bytes > MAX_BYTES) {
 					truncated = true;
@@ -91,8 +93,3 @@ export function makeReadOverride(cwd: string) {
 		},
 	};
 }
-
-/** 供 edit override 复用：取某 path 的已记录快照（按 canonical path）。 */
-export function lookupSnapshot(cwd: string, p: string) {
-	return getSnapshot(canonicalPath(cwd, p));
-}

package/src/pi/state.ts

@@ -1,27 +1,18 @@
 /**
- * Session 级状态：文件快照存储（LRU）+ 配置。
+ * Session-level config holder.
  *
- * globalThis 单例（规避 Bun module identity 问题，见仓库 AGENTS）。
- * 快照 LRU 驱逐（默认 64 个文件），防长会话内存无限增长——冷文件被新文件挤出。
- * read 记录、edit 校验；key 为 canonical 绝对路径。
- * config 放 state，session_start 重载。
+ * globalThis singleton (consistent with the repo's module-identity guidance).
+ * Config is loaded on session_start and read by the read/edit overrides.
  *
  * @module pi-hashline-edit/pi
  */
 
-import { createSnapshot } from "../core/snapshot.ts";
-import type { FileSnapshot } from "../core/types.ts";
 import type { HashlineEditConfig } from "./config.ts";
 
 const GLOBAL_KEY = "__piHashlineEdit";
 const DEFAULT_CONFIG: HashlineEditConfig = { enabled: true, hashLen: 4 };
-/** 最多缓存的文件快照数；超出按 LRU 驱逐最久未访问的。 */
-const MAX_SNAPSHOTS = 64;
 
 export interface HashlineEditState {
-	/** canonical path → 快照。LRU 顺序：Map 插入序，最近访问的在末尾。 */
-	readonly snapshots: Map<string, FileSnapshot>;
-	hashLen: number;
 	config: HashlineEditConfig;
 }
 
@@ -29,51 +20,7 @@ export function getState(): HashlineEditState {
 	const g = globalThis as Record<string, unknown>;
 	const existing = g[GLOBAL_KEY];
 	if (existing) return existing as HashlineEditState;
-	const state: HashlineEditState = {
-		snapshots: new Map(),
-		hashLen: DEFAULT_CONFIG.hashLen,
-		config: DEFAULT_CONFIG,
-	};
+	const state: HashlineEditState = { config: DEFAULT_CONFIG };
 	g[GLOBAL_KEY] = state;
 	return state;
 }
-
-/** 写入快照并维持 LRU：移到末尾（最近使用），超限驱逐最旧（Map 首项）。 */
-function touchAndEvict(map: Map<string, FileSnapshot>, path: string, snap: FileSnapshot): void {
-	if (map.has(path)) map.delete(path);
-	map.set(path, snap);
-	while (map.size > MAX_SNAPSHOTS) {
-		const oldest = map.keys().next().value;
-		if (oldest === undefined) break;
-		map.delete(oldest);
-	}
-}
-
-/** 记录文件快照（read 时调用）：算行 hash + LRU。 */
-export function recordSnapshot(canonicalPath: string, text: string): FileSnapshot {
-	const state = getState();
-	const snap = createSnapshot(canonicalPath, text, state.hashLen);
-	touchAndEvict(state.snapshots, canonicalPath, snap);
-	return snap;
-}
-
-/** 存入已算好的快照（edit 成功后更新），走 LRU。 */
-export function putSnapshot(canonicalPath: string, snap: FileSnapshot): void {
-	touchAndEvict(getState().snapshots, canonicalPath, snap);
-}
-
-/** 取文件快照（edit 校验用）；命中时移到末尾（LRU touch）。 */
-export function getSnapshot(canonicalPath: string): FileSnapshot | undefined {
-	const map = getState().snapshots;
-	const snap = map.get(canonicalPath);
-	if (snap) {
-		map.delete(canonicalPath);
-		map.set(canonicalPath, snap);
-	}
-	return snap;
-}
-
-/** 清空快照（session 重启时）。 */
-export function clearSnapshots(): void {
-	getState().snapshots.clear();
-}

package/src/core/diff.test.ts

@@ -1,21 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { buildDiff } from "./diff.ts";
-
-test("单 hunk", () => {
-	const d = buildDiff("f.ts", ["a", "b", "c"], [{ lo: 1, hi: 2, newLines: ["X"] }]);
-	assert.ok(d.startsWith("--- a/f.ts\n"));
-	assert.ok(d.includes("+++ b/f.ts"));
-	assert.ok(d.includes("@@ -2 +2 @@"));
-	assert.ok(d.includes("-b"));
-	assert.ok(d.includes("+X"));
-});
-
-test("多行 range hunk 带计数", () => {
-	const d = buildDiff("f", ["a", "b", "c", "d"], [{ lo: 0, hi: 3, newLines: ["X"] }]);
-	assert.ok(d.includes("@@ -1,3 +1 @@")); // newCount=1 时省略计数（git 惯例）
-});
-
-test("空 ops 返回空串", () => {
-	assert.equal(buildDiff("f", ["a"], []), "");
-});

package/src/core/diff.ts

@@ -1,39 +0,0 @@
-/**
- * 基于 ops 的 unified diff 预览。
- *
- * 每个 SpanOp 生成一个 hunk，`@@` 行号基于原始文件（多 op 时各自的原始位置），
- * 内容准确。这是 Phase 1 的近似实现；如需精确的多 op 行号可后续换 LCS。
- *
- * @module pi-hashline-edit/core
- */
-
-interface SpanOpLike {
-	lo: number;
-	hi: number;
-	newLines: string[];
-}
-
-/**
- * 生成 unified diff。
- *
- * @param path     文件路径（用于 diff 头）
- * @param oldLines 应用前的原始行数组
- * @param ops      已应用的行级操作
- */
-export function buildDiff(path: string, oldLines: readonly string[], ops: readonly SpanOpLike[]): string {
-	if (ops.length === 0) return "";
-	const out: string[] = [`--- a/${path}`, `+++ b/${path}`];
-	for (const op of ops) {
-		const oldCount = op.hi - op.lo;
-		const oldStart = oldCount === 0 ? op.lo : op.lo + 1; // 零宽（插入点）用 lo，符合 unified-diff "after line N" 惯例
-		const newCount = op.newLines.length;
-		const newStart = op.lo + 1;
-		// 单行 hunk 省略计数，符合 unified-diff 惯例
-		const oldRange = oldCount === 1 ? `${oldStart}` : `${oldStart},${oldCount}`;
-		const newRange = newCount === 1 ? `${newStart}` : `${newStart},${newCount}`;
-		out.push(`@@ -${oldRange} +${newRange} @@`);
-		for (let i = op.lo; i < op.hi; i++) out.push(`-${oldLines[i]}`);
-		for (const nl of op.newLines) out.push(`+${nl}`);
-	}
-	return out.join("\n") + "\n";
-}