@wierdbytes/pi-facelift 0.3.2 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # Changelog
 
+## 0.4.0
+
+- **New**: GitHub-style split/unified diff renderer for the `write`
+  and `edit` tools, ported from `@heyhuynhgiabuu/pi-diff` and rebuilt
+  on `@wierdbytes/pi-common/diff` so the body slots cleanly inside
+  the facelift open-right frame. Each edit in a multi-edit call gets
+  its own `Edit i/N` block with the per-edit summary; the overall
+  `+A -B (M diff lines)` summary sits in the bottom border. Word-
+  level emphasis (`Diff.diffWords`) is layered on paired 1:1
+  del/add lines.
+- **New**: per-edit line-number shifting. `parseDiff` only sees a
+  snippet, so a previous pass numbered every edit from line 1
+  regardless of where it lived in the file. Now the wrapper
+  snapshots the file before `execute`, resolves each `oldText` via
+  `indexOf`, and shifts `oldNum`/`newNum` accordingly. A
+  `cumulativeDelta` keeps multi-edit new-side numbers consistent for
+  the common in-order case.
+- **New**: persistent per-package config at
+  `~/.pi/agent/wierd-facelift/config.json` (or
+  `${PI_AGENT_DIR}/wierd-facelift/config.json`). Schema today is just
+  `{ diffLayout: 'consistent' | 'split' | 'unified' | 'per-edit' }`
+  but designed to accept more knobs without breaking older files.
+  Sanitised on every load — hand-edits with typos fall back to
+  defaults.
+- **New**: `/facelift` slash command — bare invocation opens a
+  `@wierdbytes/pi-common`-backed settings overlay (matches
+  `/voice` / `/web` look). Subcommands: `status` prints config +
+  path, `reset` restores defaults.
+- **Change**: `consistent` is the default `diffLayout`. All edits in
+  one tool call share one layout: split iff every diff fits without
+  excessive line wrapping, otherwise unified for all. Stops
+  `Edit 1 split, Edit 2 unified` mixed renders. `DIFF_LAYOUT=...` env
+  var seeds the config on first run.
+- **Fix**: bottom frame border no longer inherits the diff body's
+  background. The diff module's `RST` no longer carries `BG_BASE`
+  through trailing newlines, so the closing `╰──…` of the open-right
+  frame stays on the same bg as the opening `╭──…`.
+- **Fix**: right-edge "notch" in split rows on odd terminal widths.
+  Each row is padded with one `\x1b[49m` cell so its visible width
+  always matches the frame chrome above/below.
+- **Dep**: bumps `@wierdbytes/pi-common` from `^0.3.0` to `^0.4.0`
+  (for the new `/diff` subpath). No env-only knobs were removed;
+  the only retained env var is `DIFF_LAYOUT` (one-shot seed).
+
 ## 0.3.2
 
 - **Change**: `bash` tool titles always render the full command, even

package/README.md

@@ -31,6 +31,14 @@ tool output.
 - **`find` / `grep`** — grouped / highlighted rendering on top of pi's
   built-in tool implementations (no extra search backend, no extra
   dependencies).
+- **`write` / `edit`** — GitHub-style side-by-side diff with syntax
+  highlighting and word-level emphasis (powered by
+  [`@wierdbytes/pi-common/diff`][cd]). All edits in one tool call share
+  a single layout by default (split when every diff fits, unified when
+  any would wrap) so `Edit 1 split, Edit 2 unified` mixed renders
+  don't happen — configurable via `diffLayout` (see below).
+
+  [cd]: ../common/README.md#diff
 
 ## Install
 
@@ -52,7 +60,53 @@ set -g allow-passthrough on
 
 ## Configuration
 
-All configuration is via environment variables — no settings file:
+### `/facelift` slash command
+
+Run `/facelift` to open the settings overlay. Bare invocation opens the
+modal; subcommands print or reset state:
+
+| Command            | Effect                                                          |
+| ------------------ | --------------------------------------------------------------- |
+| `/facelift`        | Open the settings overlay.                                      |
+| `/facelift status` | Print current config + the config-file path.                    |
+| `/facelift reset`  | Reset every knob to defaults and persist.                       |
+
+The overlay matches the look of `/voice`, `/web`, `/statusline` from the
+same monorepo. Changes are persisted to disk immediately on each tweak.
+
+### Config file
+
+Per-package state lives at:
+
+```
+~/.pi/agent/wierd-facelift/config.json
+```
+
+(or `${PI_AGENT_DIR}/wierd-facelift/config.json` if `PI_AGENT_DIR` is
+set). The file is seeded on first run and re-sanitised on every load,
+so hand-edits with typos won't crash the extension — unknown fields
+fall back to defaults.
+
+Current schema:
+
+```jsonc
+{
+  // "consistent" (default): one layout per tool call. If every diff
+  //   in the call fits without excessive line wrapping → split; else
+  //   → unified for all. Avoids `Edit 1 split, Edit 2 unified` mixed
+  //   renders in a single edit call.
+  // "split"     : always side-by-side, even when long lines wrap.
+  // "unified"   : always stacked single-column.
+  // "per-edit"  : each diff picks independently (original pi-diff
+  //               behaviour; can produce mixed layouts).
+  "diffLayout": "consistent"
+}
+```
+
+### Environment variables (cosmetic knobs)
+
+These stay env-only because they're either rendering tunables (Shiki,
+icons, image protocols) or boot-time toggles:
 
 | Variable                       | Default         | Notes                                                                         |
 | ------------------------------ | --------------- | ----------------------------------------------------------------------------- |
@@ -62,6 +116,7 @@ All configuration is via environment variables — no settings file:
 | `FACELIFT_CACHE_LIMIT`         | `128`           | Max number of highlighted blocks held in memory.                              |
 | `FACELIFT_ICONS`               | `nerd`          | Set to `none` / `off` to disable Nerd Font icons in `ls`/`find`/`grep`.       |
 | `FACELIFT_IMAGE_PROTOCOL`      | auto            | Force `kitty` / `iterm2` / `none`. Auto-detected from `$TERM_PROGRAM` etc.    |
+| `DIFF_LAYOUT`                  | (none)          | One-shot override for `diffLayout` on first-run seeding.                      |
 
 ## Development
 

package/config.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Round-trip tests for @wierdbytes/pi-facelift's persistent config.
+ *
+ * Mirrors the contract enforced by packages/voice/config.test.ts and
+ * packages/web/config.test.ts:
+ *
+ *   • `envDefaults()` honours the DIFF_LAYOUT env var when valid, falls
+ *     back to "consistent" otherwise.
+ *   • `sanitize()` (via `loadConfig`) drops unknown / malformed fields
+ *     instead of throwing.
+ *   • `saveConfig` + `loadConfig` round-trip every valid layout value
+ *     through disk without mutation.
+ *   • `loadOrInitConfig` seeds a missing file from env defaults and
+ *     writes it to disk.
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+	envDefaults,
+	loadConfig,
+	loadOrInitConfig,
+	saveConfig,
+	VALID_DIFF_LAYOUTS,
+	type WierdFaceliftConfig,
+} from "./config.ts";
+
+let dir: string;
+let configFile: string;
+const savedEnv: Record<string, string | undefined> = {};
+
+beforeEach(() => {
+	dir = mkdtempSync(join(tmpdir(), "facelift-config-"));
+	configFile = join(dir, "config.json");
+	savedEnv.DIFF_LAYOUT = process.env.DIFF_LAYOUT;
+	delete process.env.DIFF_LAYOUT;
+});
+
+afterEach(() => {
+	if (savedEnv.DIFF_LAYOUT !== undefined) process.env.DIFF_LAYOUT = savedEnv.DIFF_LAYOUT;
+	else delete process.env.DIFF_LAYOUT;
+	rmSync(dir, { recursive: true, force: true });
+});
+
+describe("envDefaults", () => {
+	it("returns 'consistent' when DIFF_LAYOUT is unset", () => {
+		expect(envDefaults()).toEqual({ diffLayout: "consistent" });
+	});
+
+	for (const layout of VALID_DIFF_LAYOUTS) {
+		it(`honours DIFF_LAYOUT=${layout}`, () => {
+			process.env.DIFF_LAYOUT = layout;
+			expect(envDefaults()).toEqual({ diffLayout: layout });
+		});
+	}
+
+	it("ignores invalid DIFF_LAYOUT values", () => {
+		process.env.DIFF_LAYOUT = "rainbow";
+		expect(envDefaults()).toEqual({ diffLayout: "consistent" });
+	});
+
+	it("is case-insensitive on DIFF_LAYOUT", () => {
+		process.env.DIFF_LAYOUT = "SPLIT";
+		expect(envDefaults()).toEqual({ diffLayout: "split" });
+	});
+});
+
+describe("loadConfig + saveConfig round-trip", () => {
+	for (const layout of VALID_DIFF_LAYOUTS) {
+		it(`persists diffLayout=${layout}`, () => {
+			saveConfig({ diffLayout: layout } as WierdFaceliftConfig, configFile);
+			expect(existsSync(configFile)).toBe(true);
+			expect(loadConfig(configFile)).toEqual({ diffLayout: layout });
+		});
+	}
+
+	it("sanitises unknown fields back to defaults", () => {
+		writeFileSync(
+			configFile,
+			JSON.stringify({ diffLayout: "consistent", iconMode: "rainbow", junk: 42 }),
+		);
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent" });
+	});
+
+	it("rejects invalid diffLayout strings and falls back to default", () => {
+		writeFileSync(configFile, JSON.stringify({ diffLayout: "tutti-frutti" }));
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent" });
+	});
+
+	it("returns defaults when the file is missing (no write)", () => {
+		expect(existsSync(configFile)).toBe(false);
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent" });
+		expect(existsSync(configFile)).toBe(false);
+	});
+
+	it("returns defaults when the file is malformed JSON", () => {
+		writeFileSync(configFile, "{ not valid json");
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent" });
+	});
+
+	it("writes a trailing newline", () => {
+		saveConfig({ diffLayout: "split" } as WierdFaceliftConfig, configFile);
+		expect(readFileSync(configFile, "utf-8").endsWith("\n")).toBe(true);
+	});
+});
+
+describe("loadOrInitConfig", () => {
+	it("seeds a missing file from env defaults", () => {
+		expect(existsSync(configFile)).toBe(false);
+		const cfg = loadOrInitConfig(configFile);
+		expect(cfg).toEqual({ diffLayout: "consistent" });
+		expect(existsSync(configFile)).toBe(true);
+		expect(JSON.parse(readFileSync(configFile, "utf-8"))).toEqual({ diffLayout: "consistent" });
+	});
+
+	it("respects DIFF_LAYOUT when seeding", () => {
+		process.env.DIFF_LAYOUT = "unified";
+		const cfg = loadOrInitConfig(configFile);
+		expect(cfg).toEqual({ diffLayout: "unified" });
+		expect(JSON.parse(readFileSync(configFile, "utf-8"))).toEqual({ diffLayout: "unified" });
+	});
+
+	it("does not overwrite an existing file", () => {
+		writeFileSync(configFile, JSON.stringify({ diffLayout: "split" }));
+		process.env.DIFF_LAYOUT = "unified"; // would override on a fresh seed
+		const cfg = loadOrInitConfig(configFile);
+		expect(cfg).toEqual({ diffLayout: "split" });
+	});
+});

package/config.ts

@@ -0,0 +1,143 @@
+/**
+ * Persistent config for @wierdbytes/pi-facelift.
+ *
+ * Stored at `<piAgentDir>/wierd-facelift/config.json`. Pattern mirrors
+ * `packages/voice/config.ts` and `packages/web/config.ts`:
+ *
+ *   - First-run load: file missing ⇒ seed from env, write to disk.
+ *   - Subsequent loads: read JSON, `sanitize()` unknown fields back to
+ *     defaults so a hand-edited file with typos doesn't crash the
+ *     extension.
+ *   - Saves write atomically (one JSON.stringify + trailing newline).
+ *
+ * The only knob we expose today is `diffLayout`, but the schema is
+ * designed to accept more fields (icon mode, max preview lines, etc.)
+ * without breaking older config files.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+import { configPath as defaultConfigPath, ensureFaceliftDir } from "./paths.ts";
+
+/**
+ * User-facing layout preference for the write/edit diff renderer.
+ *
+ * Mirrors `DiffLayoutPreference` from `@wierdbytes/pi-common/diff`. We
+ * re-declare it here so the config module has no runtime dependency on
+ * the diff package — the two values are kept in sync by the
+ * `decideDiffLayout` helper in `index.ts`.
+ */
+export const VALID_DIFF_LAYOUTS = ["consistent", "split", "unified", "per-edit"] as const;
+export type DiffLayoutPreference = (typeof VALID_DIFF_LAYOUTS)[number];
+export const DEFAULT_DIFF_LAYOUT: DiffLayoutPreference = "consistent";
+
+export interface WierdFaceliftConfig {
+	/**
+	 * How to pick split-vs-unified for write/edit diffs:
+	 *
+	 *   • `"consistent"` (default) — one layout per tool call. If every
+	 *     diff fits without excessive line wrapping → split; else →
+	 *     unified for all. Avoids `Edit 1 split, Edit 2 unified` mixed
+	 *     renders within one tool call.
+	 *   • `"split"`     — always side-by-side, even when long lines
+	 *     wrap.
+	 *   • `"unified"`   — always stacked single-column.
+	 *   • `"per-edit"`  — each diff picks independently (original
+	 *     pi-diff behaviour; can produce mixed layouts in one call).
+	 */
+	diffLayout: DiffLayoutPreference;
+}
+
+function isDiffLayout(value: unknown): value is DiffLayoutPreference {
+	return typeof value === "string" && (VALID_DIFF_LAYOUTS as readonly string[]).includes(value);
+}
+
+/**
+ * Seed defaults from the environment. `DIFF_LAYOUT` is the only env
+ * override today; everything else falls back to the hard-coded default.
+ *
+ * The env var is read at every defaults() call, not cached at module
+ * load, so callers can change it between tests / sub-processes without
+ * having to re-import the module.
+ */
+export function envDefaults(): WierdFaceliftConfig {
+	const envLayout = process.env.DIFF_LAYOUT?.trim().toLowerCase();
+	const fromEnv = envLayout && isDiffLayout(envLayout) ? envLayout : undefined;
+	return {
+		diffLayout: fromEnv ?? DEFAULT_DIFF_LAYOUT,
+	};
+}
+
+function sanitize(raw: unknown): WierdFaceliftConfig {
+	const defaults = envDefaults();
+	if (!raw || typeof raw !== "object") return defaults;
+	const obj = raw as Record<string, unknown>;
+	const cfg: WierdFaceliftConfig = { ...defaults };
+	if (isDiffLayout(obj.diffLayout)) cfg.diffLayout = obj.diffLayout;
+	return cfg;
+}
+
+/**
+ * Canonical config path. Wrapper around `paths.ts` so callers (status
+ * commands, error messages) have a single import target.
+ */
+export function getConfigPath(): string {
+	return defaultConfigPath();
+}
+
+/**
+ * Load config from disk. Missing / unreadable file ⇒ env-seeded
+ * defaults (no write). Unknown fields are silently dropped.
+ */
+export function loadConfig(path: string = defaultConfigPath()): WierdFaceliftConfig {
+	try {
+		if (!existsSync(path)) return envDefaults();
+		const raw = readFileSync(path, "utf-8");
+		return sanitize(JSON.parse(raw));
+	} catch {
+		return envDefaults();
+	}
+}
+
+/**
+ * Persist config to disk. Creates the parent directory if missing.
+ * Returns the path written to so callers can echo it in a status
+ * message.
+ */
+export function saveConfig(
+	cfg: WierdFaceliftConfig,
+	path: string = defaultConfigPath(),
+): string {
+	if (path === defaultConfigPath()) {
+		ensureFaceliftDir();
+	} else {
+		const dir = dirname(path);
+		if (dir && !existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+	}
+	const out: Record<string, unknown> = {
+		diffLayout: cfg.diffLayout,
+	};
+	writeFileSync(path, `${JSON.stringify(out, null, 2)}\n`, "utf-8");
+	return path;
+}
+
+/**
+ * Load config, seeding the file if missing. Used at extension boot so
+ * users discover the config location naturally (via `/facelift` →
+ * "config: ...") even before they edit anything.
+ */
+export function loadOrInitConfig(path: string = defaultConfigPath()): WierdFaceliftConfig {
+	if (!existsSync(path)) {
+		const seeded = envDefaults();
+		try {
+			saveConfig(seeded, path);
+		} catch {
+			// Non-fatal: fall back to in-memory defaults if disk write fails.
+		}
+		return seeded;
+	}
+	return loadConfig(path);
+}

package/edit-line-numbers.test.ts

@@ -0,0 +1,231 @@
+/**
+ * Regression tests for `edit`-tool line-number shifting.
+ *
+ * Bug history: the wrapper called `parseDiff(op.oldText, op.newText)`
+ * with just the per-edit snippets, so every diff was numbered from
+ * line 1 \u2014 even when the edit modified line 50 of the file. The user
+ * screenshot showed `1 -`/`1 +` for a change that actually replaced
+ * line 3 of `README.md`.
+ *
+ * The fix snapshots the file BEFORE running the original edit
+ * `execute`, then for each edit shifts `oldNum`/`newNum` of every diff
+ * line by the file offset where `op.oldText` lives. A `cumulativeDelta`
+ * keeps the new-side numbers consistent when earlier edits in the same
+ * call add/remove lines.
+ *
+ * These tests pin both invariants so a future refactor can't silently
+ * drift the gutter numbers again.
+ */
+
+import { describe, expect, it } from "vitest";
+
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import piFaceliftExtension from "./index.ts";
+
+class MockText {
+	private text = "";
+	constructor(_text = "", _x = 0, _y = 0) {}
+	setText(value: string) {
+		this.text = value;
+	}
+	getText() {
+		return this.text;
+	}
+}
+
+function mockToolFactory(exec: any) {
+	return (_cwd: string) => ({
+		name: "mock",
+		description: "mock",
+		parameters: { type: "object", properties: {} },
+		execute: exec,
+	});
+}
+
+function loadEditTool(editExec: any) {
+	const noopExec = async () => ({ content: [{ type: "text", text: "" }] });
+	const tools = new Map<string, any>();
+	const pi = {
+		registerTool: (tool: any) => tools.set(tool.name, tool),
+		registerCommand: () => {},
+		on: () => {},
+	};
+
+	piFaceliftExtension(pi, {
+		sdk: {
+			createReadToolDefinition: mockToolFactory(noopExec),
+			createBashToolDefinition: mockToolFactory(noopExec),
+			createLsToolDefinition: mockToolFactory(noopExec),
+			createFindToolDefinition: mockToolFactory(noopExec),
+			createGrepToolDefinition: mockToolFactory(noopExec),
+			createWriteToolDefinition: mockToolFactory(noopExec),
+			createEditToolDefinition: mockToolFactory(editExec),
+			getAgentDir: () => "/tmp/pi-facelift-test",
+		},
+		TextComponent: MockText,
+	});
+
+	return tools.get("edit");
+}
+
+interface DiffLine {
+	type: "ctx" | "add" | "del" | "sep";
+	oldNum: number | null;
+	newNum: number | null;
+	content: string;
+}
+
+interface EditEntry {
+	oldText: string;
+	newText: string;
+	diff: { lines: DiffLine[]; added: number; removed: number };
+}
+
+interface EditDetails {
+	_type: "editDiff";
+	edits: EditEntry[];
+}
+
+describe("edit execute: per-edit line-number offsets", () => {
+	it("shifts diff line numbers to match where the edit lives in the file", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "facelift-edit-lineno-"));
+		const file = join(dir, "README.md");
+		const original = [
+			"# pi-wierd-stuff", // 1
+			"", // 2
+			"Monorepo for various extensions for the [pi](https://github.com/badlogic/pi-mono) coding agent.", // 3
+			"", // 4
+			"## Packages", // 5
+		].join("\n");
+		writeFileSync(file, original, "utf-8");
+
+		// Mock the original edit `execute` \u2014 we don't need it to actually
+		// rewrite the file. The wrapper reads the file BEFORE calling
+		// us, then attaches `details` based on its in-memory copy of
+		// the edits.
+		const editTool = loadEditTool(async () => ({
+			content: [
+				{
+					type: "text",
+					text: "Successfully replaced 1 block(s) in README.md.",
+				},
+			],
+		}));
+
+		const oldLine =
+			"Monorepo for various extensions for the [pi](https://github.com/badlogic/pi-mono) coding agent.";
+		const newLine =
+			"Monorepo for various extensions for the [pi](https://github.com/earendil-works/pi) coding agent.";
+
+		const result = await editTool.execute(
+			"t1",
+			{
+				path: file,
+				edits: [{ oldText: oldLine, newText: newLine }],
+			},
+			null,
+			null,
+			{},
+		);
+
+		const details = result.details as EditDetails;
+		expect(details._type).toBe("editDiff");
+		expect(details.edits).toHaveLength(1);
+
+		const lines = details.edits[0].diff.lines;
+		const del = lines.find((l) => l.type === "del");
+		const add = lines.find((l) => l.type === "add");
+		expect(del?.oldNum).toBe(3);
+		expect(add?.newNum).toBe(3);
+
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	it("tracks cumulative line delta across multiple edits in one call", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "facelift-edit-cumdelta-"));
+		const file = join(dir, "src.ts");
+		const original = [
+			"export const A = 1;", // 1
+			"export const B = 2;", // 2
+			"export const C = 3;", // 3
+			"export const D = 4;", // 4
+			"export const E = 5;", // 5
+		].join("\n");
+		writeFileSync(file, original, "utf-8");
+
+		const editTool = loadEditTool(async () => ({
+			content: [{ type: "text", text: "Successfully replaced 2 block(s) in src.ts." }],
+		}));
+
+		const result = await editTool.execute(
+			"t2",
+			{
+				path: file,
+				edits: [
+					// Edit 1 at line 2: replace with two lines (net +1).
+					{ oldText: "export const B = 2;", newText: "export const B = 2;\nexport const BB = 22;" },
+					// Edit 2 at line 4: simple in-place replacement (net 0).
+					{ oldText: "export const D = 4;", newText: "export const D = 40;" },
+				],
+			},
+			null,
+			null,
+			{},
+		);
+
+		const details = result.details as EditDetails;
+		expect(details.edits).toHaveLength(2);
+
+		// Edit 1: oldNum starts at line 2, newNum starts at line 2.
+		{
+			const lines = details.edits[0].diff.lines;
+			const del = lines.find((l) => l.type === "del");
+			const adds = lines.filter((l) => l.type === "add");
+			expect(del?.oldNum).toBe(2);
+			expect(adds.map((l) => l.newNum)).toEqual([2, 3]);
+		}
+
+		// Edit 2: oldNum at file line 4. newNum should already be
+		// shifted by the +1 introduced by Edit 1 \u2192 line 5.
+		{
+			const lines = details.edits[1].diff.lines;
+			const del = lines.find((l) => l.type === "del");
+			const add = lines.find((l) => l.type === "add");
+			expect(del?.oldNum).toBe(4);
+			expect(add?.newNum).toBe(5);
+		}
+
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	it("falls back to line 1 when the file can't be read (graceful, no throw)", async () => {
+		// Point at a path that does not exist. The wrapper should
+		// swallow the read error and leave diff numbers starting at 1
+		// rather than crashing the tool call.
+		const editTool = loadEditTool(async () => ({
+			content: [{ type: "text", text: "Successfully replaced 1 block(s) in missing.md." }],
+		}));
+
+		const result = await editTool.execute(
+			"t3",
+			{
+				path: "/tmp/this-path-does-not-exist-12345/missing.md",
+				edits: [{ oldText: "a", newText: "b" }],
+			},
+			null,
+			null,
+			{},
+		);
+
+		const details = result.details as EditDetails;
+		expect(details.edits).toHaveLength(1);
+		const lines = details.edits[0].diff.lines;
+		const del = lines.find((l) => l.type === "del");
+		const add = lines.find((l) => l.type === "add");
+		expect(del?.oldNum).toBe(1);
+		expect(add?.newNum).toBe(1);
+	});
+});