@jerryan/pi-hashline-edit 0.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RimuruW
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+![pi-hashline-edit](assets/banner.jpeg)
+
+# pi-hashline-edit
+
+A [pi-coding-agent](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent) extension that replaces the built-in `read` and `edit` tools with a hash-anchored line-editing workflow.
+
+Every line returned by `read` carries a short content hash. Edits reference these hashes instead of raw text, so the tool can detect stale context and reject outdated changes before they reach the file.
+
+Inspired by [oh-my-pi](https://github.com/can1357/oh-my-pi).
+
+## Differences from upstream
+
+This is a fork of the original [pi-hashline-edit](https://github.com/earendil-works/pi-hashline-edit). The core protocol (hash-anchored reads, stale-anchor rejection, atomic writes) is unchanged from upstream. Key differences:
+
+- **Single edit shape.** One entry type: `{ range: [start, end], lines: [...] }`. No `op` field, no `append`/`prepend`/`replace_text` ops, no `after`/`before`. The tuple enforces explicit endpoint anchors, eliminating the common "forgot `end`" failure mode.
+- **Standard hex hash alphabet.** `0-9 A-F` instead of `ZPMQVRWSNKTXJBYH`. Hex pairs are more likely to be single tokens.
+- **Symmetric boundary-duplication detection.** Runtime warnings catch duplicated boundary lines on both sides of a replacement, not just trailing.
+- **`read` raw mode.** `raw: true` returns plain text without `LINE#HASH:` anchors, for reads that don't plan to edit.
+- **Inline FNV-1a hashing.** Replaces `xxhashjs` dependency. Always incorporates line index.
+- **Minimal prompt surface.** Prompt text describes what the model needs to use the tool; return-format documentation and error catalogues are omitted.
+- **No legacy compatibility.** The `{ oldText, newText }` substring-replace format is not accepted. The schema is hashline-only.
+
+## Installation
+
+```bash
+# From npm
+pi install npm:pi-hashline-edit
+
+# From a local checkout
+pi install /path/to/pi-hashline-edit
+```
+
+## How It Works
+
+### `read` — tagged line output
+
+Text files are returned with a `LINE#HASH:` prefix on every line. Line numbers may be left-padded within each returned block so the `#HASH:` columns align:
+
+```text
+ 8#A4:function hello() {
+ 9#3F:  console.log("world");
+10#B2:}
+```
+
+- `LINE` — 1-indexed line number.
+- `HASH` — 2-character content hash (hex digits `0-9 A-F`).
+
+Optional parameters:
+- `offset` — start reading from this line number (1-indexed).
+- `limit` — maximum number of lines to return.
+- `raw` — when `true`, returns plain text without LINE#HASH anchors. Saves tokens when you don't plan to edit this file.
+
+Images (JPEG, PNG, GIF, WebP) are passed through as attachments and do not participate in the hashline protocol. Binary and directory paths are rejected with a descriptive error.
+
+### `edit` — hash-anchored modifications
+
+Each edit entry replaces an inclusive anchor range:
+
+```json
+{
+  "path": "src/main.ts",
+  "edits": [
+    { "range": ["11#3F", "11#3F"], "lines": ["  console.log('hashline');"] },
+    { "range": ["42#B2", "45#C7"], "lines": ["function foo() {", "  return 42;", "}"] }
+  ]
+}
+```
+
+- `range` — `[start, end]` pair of LINE#HASH anchors. Use the same anchor twice for single-line.
+- `lines` — new content replacing the range (string array). Use `[]` to delete.
+
+All edits in a single call validate against the same pre-edit snapshot and apply bottom-up, so line numbers stay consistent across operations.
+
+### Chained edits
+
+After a successful edit, the result includes an `--- Updated anchors ---` block with fresh `LINE#HASH` references for the changed region. These can be used directly in the next `edit` call on the same file without a full re-read, provided the next edit targets the same or nearby lines. For distant changes, use `read` first.
+
+### Diff preview
+
+Each edit result includes a compact `Diff preview:` block showing the changed lines with `+`/`-` markers and their new `LINE#HASH` anchors, making quick follow-up edits possible without a full re-read.
+
+## Design Decisions
+
+- **Stale anchors fail.** A hash mismatch means the file has changed since the last `read`. The error includes a snippet with fresh `LINE#HASH` references for the affected lines for immediate retry.
+- **No fallback relocation.** Mismatched anchors are never silently relocated to a "close enough" line. This trades convenience for correctness.
+- **Strict patch content.** If `lines` contains `LINE#HASH:` display prefixes or diff `+`/`-` markers, the edit is rejected with `[E_INVALID_PATCH]`. The model must send literal file content; the runtime does not silently strip accidental prefixes.
+- **Atomic writes.** Files are written via temp-file-then-rename to avoid corruption from interrupted writes. Symlink chains are resolved so the target file is updated without replacing the symlink. Hard-linked files are updated in place to preserve the shared inode. File permissions are preserved across atomic renames.
+- **Per-file mutation queue.** Edits queue by the canonical write target, so concurrent edits through different symlink paths still serialize onto the same underlying file.
+- **Schema-delegated validation.** Field-type and schema validation are the responsibility of pi's AJV layer. The extension's runtime guard only prevents crashes from missing required top-level fields.
+
+## Hashing
+
+Hashes are computed with inline FNV-1a (32-bit, mask-reduced to 8 bits), then mapped to a 2-character hex string from `0-9 A-F`.
+
+The line index is always incorporated into the hash, so identical content on different lines produces different hashes.
+
+## Development
+
+Requires [Node.js](https://nodejs.org) and npm.
+
+```bash
+npm install
+npm test
+```
+
+Set `PI_HASHLINE_DEBUG=1` to show an "active" notification at session start.
+
+## Credits
+
+Thanks to [can1357](https://github.com/can1357) for the original [oh-my-pi](https://github.com/can1357/oh-my-pi) implementation and the hashline concept.
+
+## License
+
+[MIT](LICENSE)

package/index.ts

@@ -0,0 +1,15 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerEditTool } from "./src/edit";
+import { registerReadTool } from "./src/read";
+
+export default function (pi: ExtensionAPI): void {
+  registerReadTool(pi);
+  registerEditTool(pi);
+
+  const debugValue = process.env.PI_HASHLINE_DEBUG;
+  if (debugValue === "1" || debugValue === "true") {
+    pi.on("session_start", async (_event, ctx) => {
+      ctx.ui.notify("Hashline Edit mode active", "info");
+    });
+  }
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@jerryan/pi-hashline-edit",
+  "version": "0.7.0",
+  "description": "Hashline read/edit tool override for pi-coding-agent",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JerryAZR/pi-hashline-edit.git"
+  },
+  "author": "JerryAZR",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "coding-agent",
+    "extension",
+    "hashline"
+  ],
+  "license": "MIT",
+  "files": [
+    "index.ts",
+    "src",
+    "prompts",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "dependencies": {
+    "diff": "^8.0.2",
+    "file-type": "^21.3.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": ">=0.74.0",
+    "@earendil-works/pi-coding-agent": ">=0.74.0",
+    "@earendil-works/pi-tui": "*",
+    "@sinclair/typebox": "*"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@types/node": "^22.0.0",
+    "ajv": "^8.20.0",
+    "vitest": "^3.0.0"
+  }
+}

package/prompts/edit-snippet.md

@@ -0,0 +1 @@
+Edit a text file via LINE#HASH anchors from read

package/prompts/edit.md

@@ -0,0 +1,23 @@
+Patch a UTF-8 text file using `LINE#HASH` anchors copied verbatim from `read`.
+
+Submit one `edit` call per file. All operations go in a single `edits` array; anchors must all come from the same pre-edit read.
+
+Each edit entry replaces an inclusive anchor range:
+```json
+{ "range": [startAnchor, endAnchor], "lines": [...] }
+```
+- `range` — `[start, end]` pair of LINE#HASH anchors from the most recent `read`.
+  Use the same anchor twice for single-line: `["42#A4", "42#A4"]`.
+- `lines` — new content replacing the range (string array). Use `[]` to delete.
+  Must be literal file content, not LINE#HASH-prefixed output. Match indentation exactly.
+
+Example:
+```json
+{ "path": "src/main.ts", "edits": [
+  { "range": ["12#3F", "12#3F"], "lines": ["const x = 1;"] },
+  { "range": ["20#B2", "25#C7"], "lines": ["function foo() {", "  return 42;", "}"] }
+] }
+
+Rules:
+- Do not guess, shift, or construct anchors. Copy them from the most recent `read` of this file.
+- Do not emit overlapping or adjacent edits — merge them into one.

package/prompts/read-guidelines.md

@@ -0,0 +1,2 @@
+- Use read before edit when you do not have current LINE#HASH anchors for the file.
+- If read is truncated, continue with the `offset` it suggests — do not guess unseen lines.

package/prompts/read-snippet.md

@@ -0,0 +1 @@
+Read a text file with LINE#HASH anchors for edit

package/prompts/read.md

@@ -0,0 +1,5 @@
+Read a UTF-8 text file or a supported image. Text lines are prefixed `LINE#HASH:content` — copy those anchors verbatim into `edit`.
+
+Use `offset` and `limit` to page through. Default cap: {{DEFAULT_MAX_LINES}} lines or {{DEFAULT_MAX_BYTES}}; when truncated, the tail of the output tells you the next `offset`.
+
+Set `raw: true` to skip LINE#HASH prefixing and return plain text. Don't use if you plan to edit this file — saves tokens on exploration, documentation, and reference reads.

package/src/edit-diff.ts

@@ -0,0 +1,428 @@
+import * as Diff from "diff";
+import {
+  computeLineHash,
+  FUZZY_HYPHENS_RE,
+  FUZZY_DOUBLE_QUOTES_RE,
+  FUZZY_SINGLE_QUOTES_RE,
+  FUZZY_UNICODE_SPACES_RE,
+} from "./hashline";
+
+// ─── Line ending normalization ──────────────────────────────────────────
+
+export function detectLineEnding(content: string): "\r\n" | "\n" {
+  const crlfIdx = content.indexOf("\r\n");
+  const lfIdx = content.indexOf("\n");
+  if (lfIdx === -1 || crlfIdx === -1) return "\n";
+  return crlfIdx < lfIdx ? "\r\n" : "\n";
+}
+
+export function normalizeToLF(text: string): string {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+export function restoreLineEndings(
+  text: string,
+  ending: "\r\n" | "\n",
+): string {
+  return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+}
+
+export function stripBom(content: string): { bom: string; text: string } {
+  return content.startsWith("\uFEFF")
+    ? { bom: "\uFEFF", text: content.slice(1) }
+    : { bom: "", text: content };
+}
+
+// ─── Fuzzy text matching ────────────────────────────────────────────────
+
+function normalizeFuzzyChar(ch: string): string {
+  return ch
+    .replace(FUZZY_SINGLE_QUOTES_RE, "'")
+    .replace(FUZZY_DOUBLE_QUOTES_RE, '"')
+    .replace(FUZZY_HYPHENS_RE, "-")
+    .replace(FUZZY_UNICODE_SPACES_RE, " ");
+}
+
+function normalizeForFuzzyMatch(text: string): string {
+  return text
+    .split("\n")
+    .map((line) => line.trimEnd())
+    .join("\n")
+    .replace(FUZZY_SINGLE_QUOTES_RE, "'")
+    .replace(FUZZY_DOUBLE_QUOTES_RE, '"')
+    .replace(FUZZY_HYPHENS_RE, "-")
+    .replace(FUZZY_UNICODE_SPACES_RE, " ");
+}
+
+function buildNormalizedWithMap(text: string): {
+  normalized: string;
+  indexMap: number[];
+} {
+  const lines = text.split("\n");
+  const normalizedChars: string[] = [];
+  const indexMap: number[] = [];
+  let originalOffset = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    const trimmed = line.replace(/\s+$/u, "");
+
+    for (let j = 0; j < trimmed.length; j++) {
+      normalizedChars.push(normalizeFuzzyChar(trimmed[j]!));
+      indexMap.push(originalOffset + j);
+    }
+
+    if (i < lines.length - 1) {
+      normalizedChars.push("\n");
+      indexMap.push(originalOffset + line.length);
+    }
+
+    originalOffset += line.length + 1;
+  }
+
+  return { normalized: normalizedChars.join(""), indexMap };
+}
+
+function mapNormalizedSpanToOriginal(
+  indexMap: number[],
+  normalizedStart: number,
+  normalizedLength: number,
+): { index: number; matchLength: number } | null {
+  if (normalizedStart < 0 || normalizedLength <= 0) return null;
+  const normalizedEnd = normalizedStart + normalizedLength;
+  if (normalizedEnd > indexMap.length) return null;
+
+  const start = indexMap[normalizedStart];
+  const end = indexMap[normalizedEnd - 1];
+  if (start === undefined || end === undefined || end < start) return null;
+
+  return { index: start, matchLength: end - start + 1 };
+}
+
+/**
+ * Find `oldText` in `content` with optional fuzzy whitespace/unicode matching.
+ * Always returns an index/length in the original content.
+ */
+export function fuzzyFindText(
+  content: string,
+  oldText: string,
+): {
+  found: boolean;
+  index: number;
+  matchLength: number;
+  usedFuzzyMatch: boolean;
+} {
+  const exactIndex = content.indexOf(oldText);
+  if (exactIndex !== -1) {
+    return {
+      found: true,
+      index: exactIndex,
+      matchLength: oldText.length,
+      usedFuzzyMatch: false,
+    };
+  }
+
+  const normalizedNeedle = normalizeForFuzzyMatch(oldText);
+  if (!normalizedNeedle.length)
+    return { found: false, index: -1, matchLength: 0, usedFuzzyMatch: false };
+
+  const { normalized, indexMap } = buildNormalizedWithMap(content);
+  const normalizedIndex = normalized.indexOf(normalizedNeedle);
+  if (normalizedIndex === -1) {
+    return { found: false, index: -1, matchLength: 0, usedFuzzyMatch: false };
+  }
+
+  const mapped = mapNormalizedSpanToOriginal(
+    indexMap,
+    normalizedIndex,
+    normalizedNeedle.length,
+  );
+  if (!mapped) {
+    return { found: false, index: -1, matchLength: 0, usedFuzzyMatch: false };
+  }
+
+  return {
+    found: true,
+    index: mapped.index,
+    matchLength: mapped.matchLength,
+    usedFuzzyMatch: true,
+  };
+}
+
+/**
+ * Replace `oldText` with `newText` in `content`.
+ * Fuzzy matching only determines target spans; replacement always applies to
+ * the original content (never normalizes the whole file).
+ */
+export function replaceText(
+  content: string,
+  oldText: string,
+  newText: string,
+  opts: { all?: boolean },
+): { content: string; count: number } {
+  if (!oldText.length) return { content, count: 0 };
+  const normalizedNew = normalizeToLF(newText);
+
+  if (opts.all) {
+    const exactCount = content.split(oldText).length - 1;
+    if (exactCount > 0) {
+      return {
+        content: content.split(oldText).join(normalizedNew),
+        count: exactCount,
+      };
+    }
+
+    const normalizedNeedle = normalizeForFuzzyMatch(oldText);
+    if (!normalizedNeedle.length) return { content, count: 0 };
+
+    const { normalized, indexMap } = buildNormalizedWithMap(content);
+    const spans: Array<{ index: number; matchLength: number }> = [];
+    let searchFrom = 0;
+
+    while (searchFrom <= normalized.length - normalizedNeedle.length) {
+      const pos = normalized.indexOf(normalizedNeedle, searchFrom);
+      if (pos === -1) break;
+      const mapped = mapNormalizedSpanToOriginal(
+        indexMap,
+        pos,
+        normalizedNeedle.length,
+      );
+      if (mapped) {
+        const prev = spans[spans.length - 1];
+        if (!prev || mapped.index >= prev.index + prev.matchLength) {
+          spans.push(mapped);
+        }
+      }
+      searchFrom = pos + Math.max(1, normalizedNeedle.length);
+    }
+
+    if (!spans.length) return { content, count: 0 };
+
+    let out = content;
+    for (let i = spans.length - 1; i >= 0; i--) {
+      const span = spans[i]!;
+      out =
+        out.substring(0, span.index) +
+        normalizedNew +
+        out.substring(span.index + span.matchLength);
+    }
+    return { content: out, count: spans.length };
+  }
+
+  const result = fuzzyFindText(content, oldText);
+  if (!result.found) return { content, count: 0 };
+
+  return {
+    content:
+      content.substring(0, result.index) +
+      normalizedNew +
+      content.substring(result.index + result.matchLength),
+    count: 1,
+  };
+}
+
+// ─── Diff generation ────────────────────────────────────────────────────
+
+function formatDiffPreviewLine(
+  prefix: " " | "+" | "-",
+  lineNum: number,
+  lineNumWidth: number,
+  line: string,
+  includeHash: boolean,
+): string {
+  const paddedLineNum = String(lineNum).padStart(lineNumWidth, " ");
+  if (!includeHash) {
+    return `${prefix}${paddedLineNum}    ${line}`;
+  }
+  return `${prefix}${paddedLineNum}#${computeLineHash(lineNum, line)}:${line}`;
+}
+
+export function generateDiffString(
+  oldContent: string,
+  newContent: string,
+  contextLines = 4,
+): { diff: string; firstChangedLine: number | undefined } {
+  const parts = Diff.diffLines(oldContent, newContent);
+  const output: string[] = [];
+  const maxLineNum = Math.max(
+    oldContent.split("\n").length,
+    newContent.split("\n").length,
+  );
+  const lineNumWidth = String(maxLineNum).length;
+  let oldLineNum = 1;
+  let newLineNum = 1;
+  let lastWasChange = false;
+  let firstChangedLine: number | undefined;
+
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i]!;
+    const raw = part.value.split("\n");
+    if (raw[raw.length - 1] === "") raw.pop();
+
+    if (part.added || part.removed) {
+      if (firstChangedLine === undefined) firstChangedLine = newLineNum;
+      for (const line of raw) {
+        if (part.added) {
+          output.push(
+            formatDiffPreviewLine("+", newLineNum, lineNumWidth, line, true),
+          );
+          newLineNum++;
+        } else {
+          output.push(
+            formatDiffPreviewLine("-", oldLineNum, lineNumWidth, line, false),
+          );
+          oldLineNum++;
+        }
+      }
+      lastWasChange = true;
+      continue;
+    }
+
+    const nextPartIsChange =
+      i < parts.length - 1 && (parts[i + 1]!.added || parts[i + 1]!.removed);
+    if (lastWasChange || nextPartIsChange) {
+      let linesToShow = raw;
+      let skipStart = 0;
+      let skipEnd = 0;
+
+      if (!lastWasChange) {
+        skipStart = Math.max(0, raw.length - contextLines);
+        linesToShow = raw.slice(skipStart);
+      }
+      if (!nextPartIsChange && linesToShow.length > contextLines) {
+        skipEnd = linesToShow.length - contextLines;
+        linesToShow = linesToShow.slice(0, contextLines);
+      }
+
+      if (skipStart > 0) {
+        output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+        oldLineNum += skipStart;
+        newLineNum += skipStart;
+      }
+      for (const line of linesToShow) {
+        output.push(
+          formatDiffPreviewLine(" ", newLineNum, lineNumWidth, line, true),
+        );
+        oldLineNum++;
+        newLineNum++;
+      }
+      if (skipEnd > 0) {
+        output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+        oldLineNum += skipEnd;
+        newLineNum += skipEnd;
+      }
+    } else {
+      oldLineNum += raw.length;
+      newLineNum += raw.length;
+    }
+    lastWasChange = false;
+  }
+
+  return { diff: output.join("\n"), firstChangedLine };
+}
+
+export interface CompactHashlineDiffPreview {
+  preview: string;
+  addedLines: number;
+  removedLines: number;
+}
+
+type DiffPreviewKind = "context" | "addition" | "deletion";
+
+function classifyDiffPreviewLine(line: string): DiffPreviewKind | null {
+  if (line.startsWith("+")) return "addition";
+  if (line.startsWith("-")) return "deletion";
+  if (line.startsWith(" ")) return "context";
+  return null;
+}
+
+function summarizeOmitted(count: number, label: string): string {
+  return `... ${count} more ${label} line${count === 1 ? "" : "s"}`;
+}
+
+function collapseDiffPreviewRun(
+  lines: string[],
+  maxVisible: number,
+  label: string,
+): string[] {
+  if (lines.length <= maxVisible) {
+    return lines;
+  }
+
+  return [
+    ...lines.slice(0, maxVisible),
+    summarizeOmitted(lines.length - maxVisible, label),
+  ];
+}
+
+export function buildCompactHashlineDiffPreview(
+  diff: string,
+  options: {
+    maxUnchangedRun?: number;
+    maxAdditionRun?: number;
+    maxDeletionRun?: number;
+    maxOutputLines?: number;
+  } = {},
+): CompactHashlineDiffPreview {
+  const {
+    maxUnchangedRun = 2,
+    maxAdditionRun = 4,
+    maxDeletionRun = 4,
+    maxOutputLines = 12,
+  } = options;
+
+  if (!diff.trim()) {
+    return { preview: "", addedLines: 0, removedLines: 0 };
+  }
+
+  const lines = diff.split("\n").filter((line) => line.length > 0);
+  const previewLines: string[] = [];
+  let addedLines = 0;
+  let removedLines = 0;
+
+  for (let index = 0; index < lines.length; ) {
+    const kind = classifyDiffPreviewLine(lines[index]!);
+    let end = index + 1;
+    while (end < lines.length && classifyDiffPreviewLine(lines[end]!) === kind) {
+      end += 1;
+    }
+
+    const run = lines.slice(index, end);
+    switch (kind) {
+      case "addition":
+        addedLines += run.length;
+        previewLines.push(...collapseDiffPreviewRun(run, maxAdditionRun, "added"));
+        break;
+      case "deletion":
+        removedLines += run.length;
+        previewLines.push(...collapseDiffPreviewRun(run, maxDeletionRun, "removed"));
+        break;
+      case "context":
+        previewLines.push(...collapseDiffPreviewRun(run, maxUnchangedRun, "unchanged"));
+        break;
+      default:
+        previewLines.push(...run);
+        break;
+    }
+
+    index = end;
+  }
+
+  if (previewLines.length > maxOutputLines) {
+    const visibleLines = previewLines.slice(0, maxOutputLines);
+    visibleLines.push(
+      summarizeOmitted(previewLines.length - maxOutputLines, "preview"),
+    );
+    return {
+      preview: visibleLines.join("\n"),
+      addedLines,
+      removedLines,
+    };
+  }
+
+  return {
+    preview: previewLines.join("\n"),
+    addedLines,
+    removedLines,
+  };
+}