@d3ara1n/pi-hashline-edit 0.1.1 → 0.1.2

package/src/pi/execute.test.ts

@@ -1,7 +1,7 @@
 /**
- * Integration tests for the pi integration layer's execute: drives the real
- * makeReadOverride/makeEditOverride execute, covering text read with anchors,
- * the hashline edit closed loop, and error returns with 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";
@@ -10,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);
 
+/** 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/);
@@ -38,88 +48,224 @@ test("read execute: text outputs LINE#HASH│content", async () => {
 	});
 });
 
-test("read execute: records a snapshot for 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 not recorded");
-		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 closed loop (read → edit → file changed)", 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, "should not be an error");
-		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: consecutive edits reuse the updated 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` });
-		// second edit: the snapshot was updated by the edit, use the new 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 execute: edit without a prior read → anchor verification fails", async () => {
+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: 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);
-		// never read, so the hash is made up
-		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: missing input → isError + missing hint", 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: legacy oldText/newText → isError + legacy hint", 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 error → 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", input: "SWAP 1#X:\n+a" });
+		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",
+			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 resolves relative/absolute", () => {
+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 array → explicit no-degradation message", () => {
-	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: top-level oldText/newText also recognized as legacy", () => {
-	const msg = missingInputError("f.ts", { oldText: "a", newText: "b" });
-	assert.ok(msg.includes("legacy"));
-});
-
-test("missingInputError: only input missing (not legacy)", () => {
-	const msg = missingInputError("f.ts", {});
-	assert.ok(msg.includes("missing"));
-	assert.ok(!msg.includes("legacy"));
-});

package/src/pi/read-tool.ts

@@ -1,7 +1,10 @@
 /**
- * Override read: text files output "lineNo#hash│content" and record a snapshot;
- * non-text (images/binary) and read errors delegate to the built-in read, whose
- * renderer is inherited automatically.
+ * 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
  */
@@ -9,13 +12,14 @@
 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: shared by read/edit to keep the snapshot key consistent. */
+/** canonical path: shared by read/edit to resolve a file consistently. */
 export function canonicalPath(cwd: string, p: string): string {
 	return resolve(cwd, p);
 }
@@ -55,9 +59,7 @@ export function makeReadOverride(cwd: string) {
 			const text = buf.toString("utf-8");
 			const allLines = splitLines(text);
 			const totalLines = allLines.length;
-
-			// record a full-file snapshot (edit anchors are based on full-file line numbers)
-			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) {
 		},
 	};
 }
-
-/** Reused by the edit override: look up a recorded snapshot for a path (by canonical path). */
-export function lookupSnapshot(cwd: string, p: string) {
-	return getSnapshot(canonicalPath(cwd, p));
-}

package/src/pi/state.ts

@@ -1,28 +1,18 @@
 /**
- * Session-level state: file snapshot store (LRU) + config.
+ * Session-level config holder.
  *
- * globalThis singleton (avoids Bun module-identity issues; see the repo AGENTS).
- * Snapshot LRU eviction (default 64 files) prevents unbounded memory growth in
- * long sessions — cold files are pushed out by new ones. read records; edit
- * verifies; key is the canonical absolute path.
- * config lives in state and is reloaded on 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 };
-/** Maximum number of cached file snapshots; beyond this the least-recently-accessed is evicted. */
-const MAX_SNAPSHOTS = 64;
 
 export interface HashlineEditState {
-	/** canonical path → snapshot. LRU order: Map insertion order, most recently accessed at the end. */
-	readonly snapshots: Map<string, FileSnapshot>;
-	hashLen: number;
 	config: HashlineEditConfig;
 }
 
@@ -30,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;
 }
-
-/** Write a snapshot and maintain LRU: move to the end (most recently used); evict the oldest (Map's first entry) when over the limit. */
-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);
-	}
-}
-
-/** Record a file snapshot (called on read): compute line hashes + LRU bookkeeping. */
-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;
-}
-
-/** Store an already-computed snapshot (updated after a successful edit), via LRU. */
-export function putSnapshot(canonicalPath: string, snap: FileSnapshot): void {
-	touchAndEvict(getState().snapshots, canonicalPath, snap);
-}
-
-/** Get a file snapshot (for edit verification); on a hit move it to the end (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;
-}
-
-/** Clear all snapshots (on session restart). */
-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("single 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("multi-line range hunk carries counts", () => {
-	const d = buildDiff("f", ["a", "b", "c", "d"], [{ lo: 0, hi: 3, newLines: ["X"] }]);
-	assert.ok(d.includes("@@ -1,3 +1 @@")); // newCount=1 omits the count (git convention)
-});
-
-test("empty ops returns empty string", () => {
-	assert.equal(buildDiff("f", ["a"], []), "");
-});

package/src/core/diff.ts

@@ -1,41 +0,0 @@
-/**
- * Ops-based unified diff preview.
- *
- * Each SpanOp produces one hunk; the `@@` line numbers are based on the
- * original file (each op's own original position), so the content is accurate.
- * This is a Phase 1 approximation; if precise multi-op line numbers are needed,
- * LCS can replace it later.
- *
- * @module pi-hashline-edit/core
- */
-
-interface SpanOpLike {
-	lo: number;
-	hi: number;
-	newLines: string[];
-}
-
-/**
- * Build a unified diff.
- *
- * @param path     file path (for the diff header)
- * @param oldLines original line array before applying
- * @param ops      line-level operations applied
- */
-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; // zero-width (insertion point) uses lo, following the unified-diff "after line N" convention
-		const newCount = op.newLines.length;
-		const newStart = op.lo + 1;
-		// single-line hunks omit the count, following the unified-diff convention
-		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";
-}

package/src/core/parse.test.ts

@@ -1,117 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { parsePatch } from "./parse.ts";
-
-test("parse replace single line", () => {
-	const r = parsePatch("file: f.ts\n\nreplace 4#ABCD:\n+new line\n");
-	assert.equal(r.ok, true);
-	if (r.ok) {
-		assert.equal(r.patch.path, "f.ts");
-		assert.equal(r.patch.edits.length, 1);
-		assert.equal(r.patch.edits[0].op, "replace");
-	}
-});
-
-test("parse replace range", () => {
-	const r = parsePatch("file: f.ts\nreplace 3#AAA..5#BBB:\n+a\n+b\n");
-	assert.equal(r.ok, true);
-	if (r.ok) {
-		const e = r.patch.edits[0];
-		if (e.op === "replace") {
-			assert.equal(e.start.line, 3);
-			assert.equal(e.end?.line, 5);
-			assert.deepEqual(e.body, ["a", "b"]);
-		}
-	}
-});
-
-test("parse delete (no body)", () => {
-	const r = parsePatch("file: f.ts\ndelete 2#XYZ\n");
-	assert.equal(r.ok, true);
-	if (r.ok) assert.equal(r.patch.edits[0].op, "delete");
-});
-
-test("parse insert_after / insert_before", () => {
-	const r = parsePatch("file: f.ts\ninsert_after 3#ABC:\n+x\n\ninsert_before 5#DEF:\n+y\n");
-	assert.equal(r.ok, true);
-	if (r.ok) assert.equal(r.patch.edits.length, 2);
-});
-
-test("parse append / prepend", () => {
-	const r = parsePatch("file: f.ts\nappend:\n+z\n\nprepend:\n+w\n");
-	assert.equal(r.ok, true);
-	if (r.ok) {
-		assert.equal(r.patch.edits[0].op, "append");
-		assert.equal(r.patch.edits[1].op, "prepend");
-	}
-});
-
-test("multiple mixed operations", () => {
-	const r = parsePatch("file: f.ts\n\nreplace 1#A:\n+x\n\ndelete 3#C\n\ninsert_after 5#E:\n+y\n");
-	assert.equal(r.ok, true);
-	if (r.ok) assert.equal(r.patch.edits.length, 3);
-});
-
-test("body kept literally (with + prefix, markdown)", () => {
-	const r = parsePatch("file: f.ts\nreplace 1#A:\n++i\n+- item\n+\n");
-	assert.equal(r.ok, true);
-	if (r.ok) {
-		const e = r.patch.edits[0];
-		if (e.op === "replace") assert.deepEqual(e.body, ["+i", "- item", ""]);
-	}
-});
-
-test("colon is optional", () => {
-	const r = parsePatch("file: f.ts\nreplace 1#A\n+x\n");
-	assert.equal(r.ok, true);
-});
-
-test("CRLF normalization", () => {
-	const r = parsePatch("file: f.ts\r\nreplace 1#A:\r\n+x\r\n");
-	assert.equal(r.ok, true);
-	if (r.ok) {
-		const e = r.patch.edits[0];
-		if (e.op === "replace") assert.deepEqual(e.body, ["x"]); // no \r
-	}
-});
-
-// --- error paths ---
-
-test("missing file header errors", () => {
-	const r = parsePatch("replace 1#A:\n+x\n");
-	assert.equal(r.ok, false);
-});
-
-test("empty input errors", () => {
-	assert.equal(parsePatch("").ok, false);
-	assert.equal(parsePatch("\n\n").ok, false);
-});
-
-test("empty body errors", () => {
-	const r = parsePatch("file: f.ts\nreplace 1#A:\n");
-	assert.equal(r.ok, false);
-	if (!r.ok) assert.equal(r.error.kind, "parse");
-});
-
-test("unknown verb errors (rejects SWAP/DEL)", () => {
-	const r = parsePatch("file: f.ts\nSWAP 1#A:\n+x\n");
-	assert.equal(r.ok, false);
-	if (!r.ok) assert.equal(r.error.kind, "parse");
-});
-
-test("stray body errors", () => {
-	const r = parsePatch("file: f.ts\n+x\n");
-	assert.equal(r.ok, false);
-});
-
-test("delete with body errors", () => {
-	const r = parsePatch("file: f.ts\ndelete 2#X\n+leak\n");
-	// a + line right after delete → the next round treats it as a stray body
-	assert.equal(r.ok, false);
-});
-
-test("error includes the input line number", () => {
-	const r = parsePatch("file: f.ts\n\nreplace 1#A:\n+x\n\nSWAP 2#B:\n+y\n");
-	assert.equal(r.ok, false);
-	if (!r.ok) assert.ok(r.error.line && r.error.line >= 5);
-});