@d3ara1n/pi-hashline-edit 0.5.0 → 0.5.2

package/src/pi/grep.test.ts

@@ -1,265 +1,312 @@
 /**
- * grep override execute tests: drive the real makeGrepOverride execute against
- * temp dirs — anchored content output, boolean combination (matchMode all /
- * excludePattern), output modes (files / count), wordMatch, multi-pattern any,
- * multi-path, context windows, ignoreCase, limit notice, and the disabled-mode
- * fallbacks (plain params delegate, extended params run un-anchored).
+ * Deterministic grep override tests. Ripgrep and built-in grep are injected;
+ * fixture files live only in a per-test system temporary directory.
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { makeGrepOverride } from "./grep-tool.ts";
-import { getState } from "./state.ts";
 import { computeLineHash } from "../core/hash.ts";
+import { makeGrepOverrideWithBackend, type GrepBackend } from "./grep-tool.ts";
+import { getState } from "./state.ts";
+
+type FakeOptions = {
+  lines?: string[];
+  code?: number | null;
+  stderr?: string;
+  error?: Error;
+  onRun?: () => void;
+};
 
 async function withDir<T>(fn: (dir: string) => Promise<T>): Promise<T> {
-	const dir = await mkdtemp(join(tmpdir(), "hl-grep-"));
-	try {
-		return await fn(dir);
-	} finally {
-		await rm(dir, { recursive: true, force: true });
-	}
+  const dir = await mkdtemp(join(tmpdir(), "hl-grep-"));
+  try {
+    return await fn(dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
 }
 
-const call = (tool: any, params: any) => tool.execute("0", params, undefined, undefined);
-
-const A = "alpha beta\ngamma\nalpha only\nbeta only\nALPHA caps\n";
-const B = "alpha here\nnothing\n";
+function rgMatch(filePath: string, lineNumber: number, text: string): string {
+  return JSON.stringify({
+    type: "match",
+    data: { path: { text: filePath }, line_number: lineNumber, lines: { text } },
+  });
+}
 
-async function seed(dir: string) {
-	await writeFile(join(dir, "a.ts"), A);
-	await writeFile(join(dir, "b.ts"), B);
+function fakeBackend(options: FakeOptions = {}) {
+  const calls: { path: string; args: string[] }[] = [];
+  const delegates: any[][] = [];
+  const backend: GrepBackend = {
+    async findRg() {
+      return "/fake/rg";
+    },
+    async runRg(path, args, _signal, onLine) {
+      calls.push({ path, args });
+      options.onRun?.();
+      if (options.error) throw options.error;
+      for (const line of options.lines ?? []) {
+        if (!onLine(line)) return { code: null, stderr: options.stderr ?? "", stopped: true };
+      }
+      return {
+        code: options.code === undefined ? 0 : options.code,
+        stderr: options.stderr ?? "",
+        stopped: false,
+      };
+    },
+    async delegate(...args) {
+      delegates.push(args);
+      return { content: [{ type: "text", text: "delegated" }], details: undefined };
+    },
+  };
+  return { backend, calls, delegates };
 }
 
-const text = (r: any): string => r.content[0].text;
+const text = (result: any): string => result.content[0].text;
+const call = (tool: any, params: any, signal?: AbortSignal) =>
+  tool.execute("0", params, signal, undefined);
 
-/** Run with hashline enabled/disabled, restoring the original config. */
 async function withEnabled<T>(enabled: boolean, fn: () => Promise<T>): Promise<T> {
-	const state = getState();
-	const prev = state.config.enabled;
-	state.config.enabled = enabled;
-	try {
-		return await fn();
-	} finally {
-		state.config.enabled = prev;
-	}
+  const state = getState();
+  const previous = state.config.enabled;
+  state.config.enabled = enabled;
+  try {
+    return await fn();
+  } finally {
+    state.config.enabled = previous;
+  }
 }
 
-test("content: single pattern groups by file with LINE#HASH anchors", async () => {
-	await withDir(async (dir) => {
-		await seed(dir);
-		const r: any = await call(makeGrepOverride(dir), { pattern: "alpha" });
-		const out = text(r);
-		assert.match(out, /a\.ts · 2 matches/);
-		assert.match(out, /b\.ts · 1 match/);
-		assert.match(out, /1#[0-9A-Z]+│alpha beta/);
-		assert.match(out, /3#[0-9A-Z]+│alpha only/);
-		assert.doesNotMatch(out, /gamma/);
-	});
-});
-
-test("content: grep anchors match the hash computed from the full line", async () => {
-	await withDir(async (dir) => {
-		await seed(dir);
-		const r: any = await call(makeGrepOverride(dir), { pattern: "alpha beta" });
-		const hash = computeLineHash(1, "alpha beta");
-		assert.match(text(r), new RegExp(`1#${hash}│alpha beta`));
-	});
-});
-
-test("matchMode all: line must match every pattern (grep A | grep B)", async () => {
-	await withDir(async (dir) => {
-		await seed(dir);
-		const r: any = await call(makeGrepOverride(dir), { pattern: ["alpha", "beta"], matchMode: "all" });
-		const out = text(r);
-		assert.match(out, /a\.ts · 1 match/);
-		assert.match(out, /1#[0-9A-Z]+│alpha beta/);
-		assert.doesNotMatch(out, /beta only/);
-		assert.doesNotMatch(out, /alpha here/);
-	});
-});
-
-test("excludePattern drops lines, like grep -v", async () => {
-	await withDir(async (dir) => {
-		await seed(dir);
-		const r: any = await call(makeGrepOverride(dir), { pattern: "alpha", excludePattern: "beta" });
-		const out = text(r);
-		assert.match(out, /a\.ts · 1 match/);
-		assert.match(out, /3#[0-9A-Z]+│alpha only/);
-		assert.match(out, /b\.ts · 1 match/);
-		assert.doesNotMatch(out, /alpha beta/);
-	});
-});
+test("formats parsed rg matches with full-line hash anchors", async () => {
+  await withDir(async (dir) =>
+    withEnabled(true, async () => {
+      const a = join(dir, "a.ts");
+      const b = join(dir, "b.ts");
+      await writeFile(a, "alpha beta\ngamma\nalpha only\n");
+      await writeFile(b, "alpha here\n");
+      const fake = fakeBackend({
+        lines: [
+          "not json",
+          JSON.stringify({ type: "begin" }),
+          rgMatch(a, 1, "alpha beta\n"),
+          rgMatch(a, 3, "alpha only\n"),
+          rgMatch(b, 1, "alpha here\n"),
+        ],
+      });
 
-test("outputMode files: one path per line, no line content", async () => {
-	await withDir(async (dir) => {
-		await seed(dir);
-		const r: any = await call(makeGrepOverride(dir), { pattern: "alpha", outputMode: "files" });
-		assert.equal(text(r), "a.ts\nb.ts");
-	});
+      const result = await call(makeGrepOverrideWithBackend(dir, fake.backend), {
+        pattern: "alpha",
+      });
+      const output = text(result);
+      assert.match(output, /a\.ts · 2 matches/);
+      assert.match(output, /b\.ts · 1 match/);
+      assert.match(output, new RegExp(`1#${computeLineHash(1, "alpha beta")}│alpha beta`));
+      assert.match(output, /3#[0-9A-Z]+│alpha only/);
+      assert.deepEqual(fake.calls[0], {
+        path: "/fake/rg",
+        args: ["--json", "--line-number", "--color=never", "--hidden", "-e", "alpha", "--", dir],
+      });
+    }),
+  );
 });
 
-test("outputMode count: per-file counts + total", async () => {
-	await withDir(async (dir) => {
-		await seed(dir);
-		const r: any = await call(makeGrepOverride(dir), { pattern: "alpha", outputMode: "count" });
-		assert.equal(text(r), "a.ts: 2\nb.ts: 1\nTotal: 3 matches in 2 files");
-	});
-});
+test("applies all, exclude, context, and CRLF filtering after rg output", async () => {
+  await withDir(async (dir) =>
+    withEnabled(true, async () => {
+      const file = join(dir, "a.ts");
+      await writeFile(
+        file,
+        "outside-before\r\nalpha beta drop\r\nbefore survivor\r\nalpha beta\r\nafter survivor\r\nalpha only\r\noutside-after\r\n",
+      );
+      const fake = fakeBackend({
+        lines: [
+          rgMatch(file, 2, "alpha beta drop\r\n"),
+          rgMatch(file, 4, "alpha beta\r\n"),
+          rgMatch(file, 6, "alpha only\r\n"),
+        ],
+      });
 
-test("wordMatch: whole words only", async () => {
-	await withDir(async (dir) => {
-		await writeFile(join(dir, "w.ts"), "foobar\nfoo bar\n");
-		const r: any = await call(makeGrepOverride(dir), { pattern: "foo", wordMatch: true });
-		const out = text(r);
-		assert.match(out, /w\.ts · 1 match/);
-		assert.match(out, /2#[0-9A-Z]+│foo bar/);
-		assert.doesNotMatch(out, /foobar/);
-	});
+      const result = await call(makeGrepOverrideWithBackend(dir, fake.backend), {
+        pattern: ["alpha", "beta$"],
+        matchMode: "all",
+        excludePattern: "drop",
+        context: 1,
+      });
+      assert.equal(
+        text(result),
+        [
+          "a.ts · 1 match",
+          `3#${computeLineHash(3, "before survivor")}│before survivor`,
+          `4#${computeLineHash(4, "alpha beta")}│alpha beta`,
+          `5#${computeLineHash(5, "after survivor")}│after survivor`,
+        ].join("\n"),
+      );
+    }),
+  );
 });
 
-test("multi-pattern any (default): OR across patterns", async () => {
-	await withDir(async (dir) => {
-		await seed(dir);
-		const r: any = await call(makeGrepOverride(dir), { pattern: ["gamma", "nothing"] });
-		const out = text(r);
-		assert.match(out, /a\.ts · 1 match/);
-		assert.match(out, /2#[0-9A-Z]+│gamma/);
-		assert.match(out, /b\.ts · 1 match/);
-		assert.match(out, /2#[0-9A-Z]+│nothing/);
-	});
-});
+test("passes output flags and formats files and counts", async () => {
+  await withDir(async (dir) =>
+    withEnabled(true, async () => {
+      const a = join(dir, "a.ts");
+      const b = join(dir, "b.ts");
+      await writeFile(a, "Foo a.b\n");
+      await writeFile(b, "foo a.b\n");
+      const fake = fakeBackend({ lines: [rgMatch(a, 1, "Foo a.b\n"), rgMatch(b, 1, "foo a.b\n")] });
 
-test("path accepts an array of search roots", async () => {
-	await withDir(async (dir) => {
-		await seed(dir);
-		const r: any = await call(makeGrepOverride(dir), { pattern: "beta only", path: ["a.ts", "b.ts"] });
-		const out = text(r);
-		assert.match(out, /4#[0-9A-Z]+│beta only/);
-		assert.match(out, /a\.ts · 1 match/);
-	});
-});
+      const files = await call(makeGrepOverrideWithBackend(dir, fake.backend), {
+        pattern: ["Foo", "a.b"],
+        path: ["a.ts", "b.ts"],
+        glob: "*.ts",
+        ignoreCase: true,
+        literal: true,
+        wordMatch: true,
+        outputMode: "files",
+      });
+      assert.equal(text(files), "a.ts\nb.ts");
+      assert.deepEqual(fake.calls[0].args, [
+        "--json",
+        "--line-number",
+        "--color=never",
+        "--hidden",
+        "--ignore-case",
+        "--fixed-strings",
+        "--word-regexp",
+        "--glob",
+        "*.ts",
+        "-e",
+        "Foo",
+        "-e",
+        "a.b",
+        "--",
+        a,
+        b,
+      ]);
 
-test("context: ±N lines around surviving matches, anchored", async () => {
-	await withDir(async (dir) => {
-		await writeFile(join(dir, "c.ts"), "l1\nl2\nl3\nl4\nl5\n");
-		const r: any = await call(makeGrepOverride(dir), { pattern: "l3", context: 1 });
-		const out = text(r);
-		assert.match(out, /c\.ts · 1 match/);
-		const rows = out.split("\n").filter((l) => /│l\d/.test(l));
-		assert.deepEqual(
-			rows.map((l) => l.replace(/#\w+│/, ":")),
-			["2:l2", "3:l3", "4:l4"],
-		);
-	});
+      const count = await call(makeGrepOverrideWithBackend(dir, fake.backend), {
+        pattern: "foo",
+        outputMode: "count",
+      });
+      assert.equal(text(count), "a.ts: 1\nb.ts: 1\nTotal: 2 matches in 2 files");
+    }),
+  );
 });
 
-test("context windows are rebuilt from surviving matches (filtered match leaks no context)", async () => {
-	await withDir(async (dir) => {
-		// l4 is a match but excluded; it sits >ctx away from the surviving l1 match,
-		// so none of its surroundings may appear as context
-		await writeFile(join(dir, "c.ts"), "target keep\nl2\nl3\ndrop me\nl5\nl6\n");
-		const r: any = await call(makeGrepOverride(dir), { pattern: "target|drop", excludePattern: "drop", context: 1 });
-		const out = text(r);
-		assert.match(out, /c\.ts · 1 match/);
-		assert.match(out, /1#[0-9A-Z]+│target keep/);
-		assert.match(out, /2#[0-9A-Z]+│l2/);
-		assert.doesNotMatch(out, /l3/);
-		assert.doesNotMatch(out, /drop me/);
-		assert.doesNotMatch(out, /l5/);
-	});
-});
+test("counts only surviving matches toward the limit and stops the fake runner", async () => {
+  await withDir(async (dir) =>
+    withEnabled(true, async () => {
+      const file = join(dir, "a.ts");
+      await writeFile(file, "alpha beta\nalpha only\nalpha later\n");
+      const fake = fakeBackend({
+        lines: [
+          rgMatch(file, 1, "alpha beta\n"),
+          rgMatch(file, 2, "alpha only\n"),
+          rgMatch(file, 3, "alpha later\n"),
+        ],
+      });
 
-test("ignoreCase matches across case variants", async () => {
-	await withDir(async (dir) => {
-		await seed(dir);
-		const r: any = await call(makeGrepOverride(dir), { pattern: "alpha", ignoreCase: true });
-		assert.match(text(r), /a\.ts · 3 matches/);
-		assert.match(text(r), /5#[0-9A-Z]+│ALPHA caps/);
-	});
+      const result = await call(makeGrepOverrideWithBackend(dir, fake.backend), {
+        pattern: "alpha",
+        excludePattern: "beta",
+        limit: 1,
+      });
+      assert.match(text(result), /2#[0-9A-Z]+│alpha only/);
+      assert.match(
+        text(result),
+        /\[1 matches limit reached\. Use limit=2 for more, or refine pattern\]/,
+      );
+    }),
+  );
 });
 
-test("limit notice suggests doubling", async () => {
-	await withDir(async (dir) => {
-		await seed(dir);
-		const r: any = await call(makeGrepOverride(dir), { pattern: "a", limit: 2 });
-		assert.match(text(r), /\[2 matches limit reached\. Use limit=4 for more, or refine pattern\]/);
-	});
-});
+test("reports empty output and ripgrep execution failures", async () => {
+  await withDir(async (dir) =>
+    withEnabled(true, async () => {
+      const empty = fakeBackend({ code: 1 });
+      assert.equal(
+        text(await call(makeGrepOverrideWithBackend(dir, empty.backend), { pattern: "missing" })),
+        "No matches found",
+      );
 
-test("filters apply before the limit counts (a filtered match consumes no budget)", async () => {
-	await withDir(async (dir) => {
-		await seed(dir);
-		// a.ts:1 "alpha beta" is excluded; pre-filter counting would burn the whole
-		// limit=1 budget on it and return nothing — post-filter counting yields a.ts:3
-		const r: any = await call(makeGrepOverride(dir), { pattern: "alpha", excludePattern: "beta", limit: 1 });
-		const out = text(r);
-		assert.match(out, /3#[0-9A-Z]+│alpha only/);
-		assert.match(out, /1 matches limit reached/);
-	});
-});
+      const failed = fakeBackend({ code: 2, stderr: "bad regex" });
+      await assert.rejects(
+        call(makeGrepOverrideWithBackend(dir, failed.backend), { pattern: "[" }),
+        /bad regex/,
+      );
 
-test("disabled + extended params: still runs, formatted without anchors", async () => {
-	await withDir(async (dir) => {
-		await seed(dir);
-		await withEnabled(false, async () => {
-			const r: any = await call(makeGrepOverride(dir), { pattern: ["alpha", "beta"], matchMode: "all" });
-			const out = text(r);
-			assert.match(out, /a\.ts:1: alpha beta/);
-			assert.doesNotMatch(out, /#[0-9A-Z]+│/);
-			assert.doesNotMatch(out, /alpha here/);
-		});
-	});
+      const rejected = fakeBackend({ error: new Error("spawn failed") });
+      await assert.rejects(
+        call(makeGrepOverrideWithBackend(dir, rejected.backend), { pattern: "x" }),
+        /spawn failed/,
+      );
+    }),
+  );
 });
 
-test("disabled + plain params: delegates to the built-in grep", async () => {
-	await withDir(async (dir) => {
-		await seed(dir);
-		await withEnabled(false, async () => {
-			const r: any = await call(makeGrepOverride(dir), { pattern: "alpha beta" });
-			// built-in format: flat `path:line: content`, no group headers
-			assert.match(text(r), /a\.ts:1: alpha beta/);
-			assert.doesNotMatch(text(r), /· 1 match/);
-		});
-	});
-});
+test("delegates only safe fallbacks and rejects extended missing-rg requests", async () => {
+  await withDir(async (dir) => {
+    const absent = fakeBackend();
+    absent.backend.findRg = async () => null;
+    await withEnabled(true, async () => {
+      assert.equal(
+        text(await call(makeGrepOverrideWithBackend(dir, absent.backend), { pattern: "x" })),
+        "delegated",
+      );
+      await assert.rejects(
+        call(makeGrepOverrideWithBackend(dir, absent.backend), {
+          pattern: ["x", "y"],
+          matchMode: "all",
+        }),
+        /ripgrep \(rg\) not found/,
+      );
+    });
 
-test("CRLF files: display and filters are \r-clean, anchors hash the clean line", async () => {
-	await withDir(async (dir) => {
-		await writeFile(join(dir, "crlf.ts"), "alpha beta\r\ngamma\r\nalpha only\r\n");
-		// anchors must hash the \r-stripped line — same splitLines as read/edit verify against
-		const hash = computeLineHash(1, "alpha beta");
-		const g: any = await call(makeGrepOverride(dir), { pattern: "alpha" });
-		const out = text(g);
-		assert.match(out, new RegExp(`1#${hash}│alpha beta`));
-		assert.ok(!/[\r]/.test(out), "no carriage returns in output");
-		// $-anchored filters must run on the cleaned text: "alpha beta\r" would dodge "beta$"
-		const g2: any = await call(makeGrepOverride(dir), { pattern: "alpha", excludePattern: "beta$" });
-		assert.match(text(g2), /alpha only/);
-		assert.doesNotMatch(text(g2), /alpha beta/);
-		// same for matchMode:"all" with a $-anchored pattern
-		const g3: any = await call(makeGrepOverride(dir), { pattern: ["alpha", "only$"], matchMode: "all" });
-		assert.match(text(g3), /3#[0-9A-Z]+│alpha only/);
-		assert.doesNotMatch(text(g3), /alpha beta/);
-	});
+    const file = join(dir, "a.ts");
+    await writeFile(file, "x y\n");
+    const disabled = fakeBackend({ lines: [rgMatch(file, 1, "x y\n")] });
+    await withEnabled(false, async () => {
+      assert.equal(
+        text(await call(makeGrepOverrideWithBackend(dir, disabled.backend), { pattern: "x" })),
+        "delegated",
+      );
+      assert.equal(disabled.calls.length, 0);
+      const extended = await call(makeGrepOverrideWithBackend(dir, disabled.backend), {
+        pattern: ["x", "y"],
+        matchMode: "all",
+      });
+      assert.match(text(extended), /a\.ts:1: x y/);
+      assert.doesNotMatch(text(extended), /#[0-9A-Z]+│/);
+      assert.equal(disabled.calls.length, 1);
+    });
+  });
 });
 
-test("literal mode escapes regex metacharacters", async () => {
-	await withDir(async (dir) => {
-		await writeFile(join(dir, "d.ts"), "a.b\naxb\n");
-		const r: any = await call(makeGrepOverride(dir), { pattern: "a.b", literal: true });
-		const out = text(r);
-		assert.match(out, /1#[0-9A-Z]+│a\.b/);
-		assert.doesNotMatch(out, /axb/);
-	});
-});
+test("delegates an already-aborted call and rejects an abort during rg execution", async () => {
+  await withDir(async (dir) => {
+    const alreadyAborted = fakeBackend();
+    const first = new AbortController();
+    first.abort();
+    assert.equal(
+      text(
+        await call(
+          makeGrepOverrideWithBackend(dir, alreadyAborted.backend),
+          { pattern: ["x", "y"] },
+          first.signal,
+        ),
+      ),
+      "delegated",
+    );
 
-test("no matches reports cleanly", async () => {
-	await withDir(async (dir) => {
-		await seed(dir);
-		const r: any = await call(makeGrepOverride(dir), { pattern: "zzz" });
-		assert.equal(text(r), "No matches found");
-	});
+    const controller = new AbortController();
+    const interrupted = fakeBackend({ onRun: () => controller.abort() });
+    await assert.rejects(
+      call(
+        makeGrepOverrideWithBackend(dir, interrupted.backend),
+        { pattern: ["x", "y"], matchMode: "all" },
+        controller.signal,
+      ),
+      /Operation aborted/,
+    );
+  });
 });

package/src/pi/pi.test.ts

@@ -2,15 +2,18 @@ import { test } from "node:test";
 import assert from "node:assert/strict";
 import { canonicalPath } from "./read-tool.ts";
 import { homedir } from "node:os";
+import { join, resolve } from "node:path";
 
 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");
+	const cwd = resolve("/cwd");
+	const absolute = resolve("/abs/x.ts");
+	assert.equal(canonicalPath(cwd, "foo.ts"), join(cwd, "foo.ts"));
+	assert.equal(canonicalPath(cwd, "./foo.ts"), join(cwd, "foo.ts"));
+	assert.equal(canonicalPath(cwd, absolute), absolute);
 });
 
 test("canonicalPath expands ~ to home directory", () => {
 	const home = homedir();
 	assert.equal(canonicalPath("/cwd", "~"), home);
-	assert.equal(canonicalPath("/cwd", "~/foo.ts"), `${home}/foo.ts`);
+	assert.equal(canonicalPath("/cwd", "~/foo.ts"), join(home, "foo.ts"));
 });

package/src/pi/read-tool.ts

@@ -15,7 +15,7 @@ import { readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { hashFileLines } from "../core/hash.ts";
-import { splitLines } from "../core/lines.ts";
+import { hasFinalNewline, splitLines } from "../core/lines.ts";
 import { getState } from "./state.ts";
 import { parseHashline } from "./render.ts";
 
@@ -60,9 +60,10 @@ function renderReadBody(raw: string, path: string, theme: any): string {
 	if (lines.length === 0) return "";
 	const out: string[] = [];
 
-	// Header: "<path> · <N> lines" optionally followed by " (from line <offset>)".
+	// Header: "<path> · <N> lines", optionally followed by " (from line <offset>)"
+	// and/or " · no trailing newline".
 	let bodyStart = 0;
-	const h = lines[0].match(/^(.+?) · (\d+ lines(?: \(from line \d+\))?)$/);
+	const h = lines[0].match(/^(.+?) · (\d+ lines(?: \(from line \d+\))?(?: · no trailing newline)?)$/);
 	if (h) {
 		out.push(theme.fg("success", h[1]) + theme.fg("dim", ` · ${h[2]}`));
 		bodyStart = 1;
@@ -184,8 +185,12 @@ export function makeReadOverride(cwd: string) {
 			}
 
 			const shownFrom = offset > 1 ? ` (from line ${offset})` : "";
+			// A file whose last line carries no terminator is a byte-level fact that the
+			// numbered rows cannot show; state it in the header, the one line the model
+			// never copies into an edit `body`.
+			const noFinalNewline = hasFinalNewline(text) ? "" : " · no trailing newline";
 			const tail = truncated ? `\n… (truncated at ${MAX_BYTES >> 10}KB; use offset/limit to read more)` : "";
-			const header = `${params.path} · ${totalLines} lines${shownFrom}\n`;
+			const header = `${params.path} · ${totalLines} lines${shownFrom}${noFinalNewline}\n`;
 			const body = rows.join("\n");
 
 			return {