pi-hashline-edit-pro 2.6.5 → 2.7.0

package/src/grep.ts

@@ -0,0 +1,323 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { readdir, stat } from "fs/promises";
+import { dirname, join, relative } from "path";
+import { loadFileKindAndText } from "./file-kind";
+import { readNormFile } from "./file-reader";
+import { MAX_HASH_LINES, HASH_SEP } from "./hashline";
+import { toCwd } from "./paths";
+import { loadP, loadGuide } from "./prompts";
+import { normReq } from "./replace-normalize";
+import { recordServedSafe } from "./served";
+import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, visLines } from "./utils";
+
+const GREP_KS = new Set(["pattern", "path", "glob", "context", "ignoreCase", "literal", "limit"]);
+const SKIP_DIRS = new Set(["node_modules", ".git", ".tmp", "coverage"]);
+const MAX_SCAN_FILES = 4000;
+const MAX_SHOWN_ROWS = 2000;
+
+export interface GrepReq {
+  pattern: string;
+  path?: string;
+  glob?: string;
+  context?: number;
+  ignoreCase?: boolean;
+  literal?: boolean;
+  limit?: number;
+}
+
+export function assertGrepReq(request: unknown): asserts request is GrepReq {
+  if (!isRec(request)) {
+    throw new Error("[E_BAD_SHAPE] Grep request must be an object.");
+  }
+  rejectUnknownFields(request, GREP_KS, "Grep request");
+  if (typeof request.pattern !== "string" || request.pattern.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Grep request requires a non-empty "pattern" string.');
+  }
+  if (request.context !== undefined && (typeof request.context !== "number" || !Number.isInteger(request.context) || request.context < 0)) {
+    throw new Error('[E_BAD_SHAPE] Grep request field "context" must be a non-negative integer.');
+  }
+  if (request.limit !== undefined && (typeof request.limit !== "number" || !Number.isInteger(request.limit) || request.limit < 1)) {
+    throw new Error('[E_BAD_SHAPE] Grep request field "limit" must be a positive integer.');
+  }
+}
+
+function buildRegex(pattern: string, literal: boolean, ignoreCase: boolean): RegExp {
+  const source = literal ? pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : pattern;
+  try {
+    return new RegExp(source, ignoreCase ? "ui" : "u");
+  } catch {
+    throw new Error(`[E_BAD_SHAPE] Invalid pattern: ${pattern}`);
+  }
+}
+
+function globToRegex(glob: string): RegExp {
+  let source = "";
+  let i = 0;
+  while (i < glob.length) {
+    const ch = glob[i]!;
+    if (ch === "*") {
+      if (glob[i + 1] === "*") {
+        i += 2;
+        if (glob[i] === "/") {
+          i += 1;
+          source += "(?:.*\\/)?";
+        } else {
+          source += ".*";
+        }
+        continue;
+      }
+      source += ".*";
+    } else if (ch === "?") {
+      source += "[^/]";
+    } else {
+      source += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+    i += 1;
+  }
+  return new RegExp(`^${source}$`);
+}
+
+function isSkipableLoadError(error: unknown): boolean {
+  const code = errCode(error);
+  if (code === "EACCES" || code === "EPERM" || code === "ENOENT" || code === "ELOOP") return true;
+  return error instanceof Error && error.message.startsWith("[E_FILE_TOO_LARGE]");
+}
+
+interface FileHit {
+  path: string;
+  displayPath: string;
+  fileHashes: string[];
+  rows: string[];
+  hashes: string[];
+  matchCount: number;
+  totalMatchCount: number;
+}
+
+interface ScanState {
+  scanned: number;
+  stopped: boolean;
+}
+
+async function walkFiles(
+  root: string,
+  state: ScanState,
+  onFile: (absPath: string) => Promise<void>,
+): Promise<void> {
+  const queue: string[] = [root];
+  while (queue.length > 0 && !state.stopped) {
+    const dir = queue.pop()!;
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (state.stopped) break;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        queue.push(full);
+      } else if (entry.isFile()) {
+        state.scanned += 1;
+        if (state.scanned > MAX_SCAN_FILES) {
+          state.stopped = true;
+          break;
+        }
+        await onFile(full);
+      }
+    }
+  }
+}
+
+async function searchFile(
+  absPath: string,
+  globRoot: string,
+  cwd: string,
+  regex: RegExp,
+  globRegex: RegExp | undefined,
+  context: number,
+  maxMatches: number,
+): Promise<FileHit | undefined> {
+  const displayPath = relative(cwd, absPath).replace(/\\/g, "/");
+  if (globRegex) {
+    const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
+    if (!globRegex.test(globPath)) return undefined;
+  }
+  let file;
+  try {
+    file = await loadFileKindAndText(absPath, { maxLines: MAX_HASH_LINES, displayPath });
+  } catch (error) {
+    if (isSkipableLoadError(error)) return undefined;
+    throw error;
+  }
+  if (file.kind !== "text") return undefined;
+  let norm;
+  try {
+    norm = await readNormFile(absPath, cwd, { maxLines: MAX_HASH_LINES, preloadedFile: file });
+  } catch (error) {
+    if (isSkipableLoadError(error)) return undefined;
+    throw error;
+  }
+  const lines = visLines(norm.normalized);
+  const matchLines: number[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (regex.test(lines[i]!)) matchLines.push(i);
+  }
+  if (matchLines.length === 0) return undefined;
+  const keptMatches = matchLines.length > maxMatches ? matchLines.slice(0, maxMatches) : matchLines;
+  const shown = new Set<number>();
+  for (const i of keptMatches) {
+    for (let j = Math.max(0, i - context); j <= Math.min(lines.length - 1, i + context); j++) shown.add(j);
+  }
+  const sorted = [...shown].sort((a, b) => a - b);
+  const rows: string[] = [];
+  const hashes: string[] = [];
+  for (const idx of sorted) {
+    rows.push(`${norm.fileHashes[idx]}${HASH_SEP}${lines[idx]}`);
+    hashes.push(norm.fileHashes[idx]!);
+  }
+  return {
+    path: norm.absolutePath,
+    displayPath,
+    fileHashes: norm.fileHashes,
+    rows,
+    hashes,
+    matchCount: keptMatches.length,
+    totalMatchCount: matchLines.length,
+  };
+}
+
+const grepToolSchema = Type.Object(
+  {
+    pattern: Type.String({
+      description: "Search pattern (regex or literal string)",
+    }),
+    path: Type.Optional(
+      Type.String({
+        description: "Directory or file to search (default: current directory)",
+      }),
+    ),
+    glob: Type.Optional(
+      Type.String({
+        description: "Filter files by glob pattern; * matches across directories, e.g. '*.ts' or '**/*.spec.ts'",
+      }),
+    ),
+    ignoreCase: Type.Optional(
+      Type.Boolean({
+        description: "Case-insensitive search (default: false)",
+      }),
+    ),
+    literal: Type.Optional(
+      Type.Boolean({
+        description: "Treat pattern as literal string instead of regex (default: false)",
+      }),
+    ),
+    context: Type.Optional(
+      Type.Integer({
+        minimum: 0,
+        description: "Number of lines to show before and after each match (default: 0)",
+      }),
+    ),
+    limit: Type.Optional(
+      Type.Integer({
+        minimum: 1,
+        description: "Maximum number of matches to return (default: 100)",
+      }),
+    ),
+  },
+  { additionalProperties: false },
+);
+
+export function regGrep(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "grep",
+    label: "Grep",
+    description: loadP("../prompts/grep.md"),
+    promptSnippet: loadP("../prompts/grep-snippet.md"),
+    promptGuidelines: loadGuide("../prompts/grep-guidelines.md"),
+    prepareArguments: makePrepareArguments(),
+    parameters: grepToolSchema,
+
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const canonical = normReq(params);
+      assertGrepReq(canonical);
+      const req = canonical;
+      const regex = buildRegex(req.pattern, req.literal === true, req.ignoreCase === true);
+      const context = req.context ?? 0;
+      const limit = req.limit ?? 100;
+      const globRegex = req.glob === undefined ? undefined : globToRegex(req.glob);
+      const base = req.path ? toCwd(req.path, ctx.cwd) : ctx.cwd;
+      abortIf(signal);
+      let baseStat;
+      try {
+        baseStat = await stat(base);
+      } catch (error) {
+        if (errCode(error) === "ENOENT") {
+          throw new Error(`[E_NOT_FOUND] File not found: ${req.path ?? ctx.cwd}`);
+        }
+        throw new Error(`[E_ACCESS] Cannot access path: ${req.path ?? ctx.cwd}`);
+      }
+      const globRoot = baseStat.isFile() ? dirname(base) : base;
+      const state: ScanState = { scanned: 0, stopped: false };
+      const files: string[] = [];
+      if (baseStat.isFile()) {
+        files.push(base);
+      } else {
+        await walkFiles(base, state, async (absPath) => {
+          files.push(absPath);
+        });
+      }
+      const hits: FileHit[] = [];
+      let matches = 0;
+      let limitTruncated = false;
+      let rowTruncated = false;
+      let rowCount = 0;
+      for (const absPath of files) {
+        abortIf(signal);
+        const remaining = limit - matches;
+        if (remaining <= 0) {
+          limitTruncated = true;
+          break;
+        }
+        const hit = await searchFile(absPath, globRoot, ctx.cwd, regex, globRegex, context, remaining);
+        if (!hit) continue;
+        const rowBudget = MAX_SHOWN_ROWS - rowCount;
+        if (rowBudget <= 0) {
+          rowTruncated = true;
+          break;
+        }
+        const keptRows = hit.rows.slice(0, rowBudget);
+        const keptHashes = hit.hashes.slice(0, rowBudget);
+        rowCount += keptRows.length;
+        if (hit.totalMatchCount > hit.matchCount) limitTruncated = true;
+        if (keptRows.length < hit.rows.length) rowTruncated = true;
+        matches += hit.matchCount;
+        hits.push({ ...hit, rows: keptRows, hashes: keptHashes });
+      }
+      for (const hit of hits) {
+        await recordServedSafe(hit.path, hit.hashes, "grep", new Set(hit.fileHashes));
+      }
+      const blocks = hits
+        .map((hit) => `=== ${hit.displayPath} ===\n${hit.rows.join("\n")}`)
+        .join("\n");
+      const notes: string[] = [];
+      if (rowTruncated) notes.push(`[grep: output truncated at ${MAX_SHOWN_ROWS} rows; refine the pattern to see more.]`);
+      if (limitTruncated) notes.push(`[grep: showing first ${limit} matches; increase limit to see more.]`);
+      if (state.stopped) notes.push(`[grep: scan cap of ${MAX_SCAN_FILES} files reached; results may be incomplete.]`);
+      const truncated = limitTruncated || rowTruncated;
+      const text = blocks.length > 0 ? `${blocks}${notes.length > 0 ? `\n${notes.join("\n")}` : ""}` : "No matches found.";
+      return {
+        content: [{ type: "text", text }],
+        details: {
+          metrics: {
+            matches,
+            files: hits.length,
+            truncated: truncated || state.stopped,
+          },
+        },
+      };
+    },
+  });
+}

package/src/hashline/index.ts

@@ -27,6 +27,8 @@ export {
 	type BDup,
 	type AutoFix,
 	resEdit,
+	stripAnchorRow,
+	resolveAnchorLine,
 	valEdit,
 	stripBarePrefixes,
 	stripDiffPrefixes,

package/src/hashline/resolve.ts

@@ -164,26 +164,29 @@ function assertItem(edit: Record<string, unknown>): void {
 
 export const ANCHOR_ROW_RE = new RegExp(`^([+-]?)(${HASH_RUN})│`);
 
+export function stripAnchorRow(
+	trimmed: string,
+	entryLabel: string,
+	warnings?: string[],
+): string {
+	const match = trimmed.match(ANCHOR_ROW_RE);
+	if (!match) return trimmed;
+	const marker =
+		match[1] === "+"
+			? "diff-preview marker"
+			: match[1] === "-"
+				? 'leading "-" marker'
+				: '"HASH│" prefix';
+	warnings?.push(`[E_BAD_REF] Stripped ${marker} from ${entryLabel} "${trimmed}".`);
+	return match[2]!;
+}
+
 export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
   assertItem(edit as Record<string, unknown>);
 
   const replaceLines = parseText(edit.replacement_lines, warnings);
   const bounds = [edit.remove_from, edit.remove_to].map((ref) => {
-    const trimmed = ref.trim();
-    const match = trimmed.match(ANCHOR_ROW_RE);
-    if (match) {
-      let message: string;
-      if (match[1] === "+") {
-        message = `[E_BAD_REF] Stripped diff-preview marker from remove_from/remove_to entry "${trimmed}".`;
-      } else if (match[1] === "-") {
-        message = `[E_BAD_REF] Stripped leading "-" marker from remove_from/remove_to entry "${trimmed}".`;
-      } else {
-        message = `[E_BAD_REF] Stripped "HASH│" prefix from remove_from/remove_to entry "${trimmed}".`;
-      }
-      warnings?.push(message);
-      return match[2]!;
-    }
-    return ref;
+    return stripAnchorRow(ref.trim(), "remove_from/remove_to entry", warnings);
   }) as [string, string];
   return {
     content_lines: replaceLines,
@@ -473,6 +476,31 @@ export function valEdit(
 	};
 }
 
+export function resolveAnchorLine(
+	ref: Anchor,
+	fileLines: string[],
+	fileHashes: string[],
+	filePath?: string,
+): number {
+	const { resolved, mismatches } = valEdit(
+		{ hash_bounds: [ref, ref], content_lines: [] },
+		fileLines,
+		fileHashes,
+		[],
+		undefined,
+	);
+	if (mismatches.length > 0 || !resolved) {
+		const feedback = fmtMismatchWithHashes(
+			mismatches,
+			fileLines,
+			fileHashes,
+			filePath,
+		);
+		throw new AnchorMismatchError(feedback.text, feedback.hashes);
+	}
+	return resolved.hash_bounds[0].line;
+}
+
 export class RangeStaleError extends Error {
   readonly firstMismatchLine: number;
   readonly rangeHashes: string[];

package/src/insert.ts

@@ -0,0 +1,222 @@
+import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { constants } from "fs";
+import { execPipeline, type ReqParams, type ReplaceDetails } from "./replace";
+import { commitEdit } from "./commit";
+import { readNormFile, type NormFile } from "./file-reader";
+import { resolveTarget } from "./fs-write";
+import { MAX_HASH_LINES, parseHashRef, resolveAnchorLine, type Anchor } from "./hashline";
+import { stripAnchorRow } from "./hashline/resolve";
+import { toCwd } from "./paths";
+import { loadP, loadGuide } from "./prompts";
+import { normReq } from "./replace-normalize";
+import { genDiff } from "./replace-diff";
+import { makeRenderCall, renderEditResult, type RPreview, type RRState } from "./replace-render";
+import { abortIf, isRec, makePrepareArguments, rejectUnknownFields, splitLines } from "./utils";
+import { clearBoundaryBypass } from "./boundary-bypass";
+
+const INSERT_KS = new Set(["path", "anchor", "direction", "lines"]);
+
+export interface InsertReq {
+  path: string;
+  anchor: string;
+  direction: "before" | "after";
+  lines: string[];
+}
+
+export function assertInsertReq(request: unknown): asserts request is InsertReq {
+  if (!isRec(request)) {
+    throw new Error("[E_BAD_SHAPE] Insert request must be an object.");
+  }
+  rejectUnknownFields(request, INSERT_KS, "Insert request");
+  if (typeof request.path !== "string" || request.path.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Insert request requires a non-empty "path" string.');
+  }
+  if (typeof request.anchor !== "string" || request.anchor.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Insert request requires an "anchor" string (3-char hash from read output).');
+  }
+  if (request.direction !== "before" && request.direction !== "after") {
+    throw new Error('[E_BAD_SHAPE] Insert request "direction" must be "before" or "after".');
+  }
+  if (!Array.isArray(request.lines) || request.lines.some((line) => typeof line !== "string")) {
+    throw new Error('[E_BAD_SHAPE] Insert request requires "lines" as an array of strings, one element per line.');
+  }
+}
+
+const insertToolSchema = Type.Object(
+  {
+    path: Type.String({
+      description:
+        "Path to the file to edit",
+    }),
+    anchor: Type.String({
+      description:
+        'Bare 3-char HASH only (e.g. "aB3"): copy just the hash from the leftmost column of a read row like `aB3│content`; never the line content. A pasted diff row like `+aB3│x` or a `HASH│` prefix is stripped automatically with a warning. The anchored line is preserved; the new lines go after or before it.',
+    }),
+    direction: Type.Union(
+      [
+        Type.Literal("after", { description: "Insert the lines after the anchor line" }),
+        Type.Literal("before", { description: "Insert the lines before the anchor line" }),
+      ],
+      { description: '"after" or "before"' },
+    ),
+    lines: Type.Array(
+      Type.String({
+        description:
+          "One line to insert. Each element is exactly one line; do not embed \\n inside an element: use separate elements.",
+      }),
+      {
+        description:
+          'Lines to insert as an array of strings, one element per line. Use [""] for a blank line. The anchor line is preserved; never include it in lines.',
+      }
+    ),
+  },
+  { additionalProperties: false },
+);
+
+function parseInsertAnchor(raw: string): { ref: Anchor; warnings: string[] } {
+  const trimmedAnchor = raw.trim();
+  const warnings: string[] = [];
+  const anchorText = stripAnchorRow(trimmedAnchor, "anchor entry", warnings);
+  return { ref: parseHashRef(anchorText), warnings };
+}
+
+function buildInsertEdit(
+  req: InsertReq,
+  preload: NormFile,
+  ref: Anchor,
+): { editParams: ReqParams; anchorLine: string | undefined } {
+  const fileLines = splitLines(preload.normalized);
+  const line = resolveAnchorLine(ref, fileLines, preload.fileHashes, req.path);
+  const anchorLine = preload.normalized.length === 0 ? undefined : fileLines[line - 1];
+  const editParams: ReqParams = {
+    path: req.path,
+    remove_from: ref.hash,
+    remove_to: ref.hash,
+    replacement_lines:
+      anchorLine === undefined
+        ? [...req.lines]
+        : req.direction === "after"
+          ? [anchorLine, ...req.lines]
+          : [...req.lines, anchorLine],
+  };
+  return { editParams, anchorLine };
+}
+
+export async function insertPreview(request: unknown, cwd: string): Promise<RPreview> {
+  try {
+    const normalized = normReq(request);
+    assertInsertReq(normalized);
+    const { ref } = parseInsertAnchor(normalized.anchor);
+    const preload = await readNormFile(normalized.path, cwd, {
+      accessMode: constants.R_OK,
+      maxLines: MAX_HASH_LINES,
+      noPersist: true,
+    });
+    const { editParams } = buildInsertEdit(normalized, preload, ref);
+    const pipe = await execPipeline(editParams, cwd, {
+      accessMode: constants.R_OK,
+      noPersist: true,
+      preloadedNorm: preload,
+      skipBoundaryDedup: true,
+    });
+    if (pipe.originalNormalized === pipe.result) {
+      return { error: `No changes made to ${normalized.path}. The edit produced identical content.` };
+    }
+    return { diff: genDiff(pipe.originalNormalized, pipe.result, 4, pipe.resultHashes, pipe.originalHashes).diff };
+  } catch (error: unknown) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function getInsertInput(args: unknown): { path?: string; anchor?: string; direction?: "before" | "after"; lines?: string[] } | null {
+  let normalized: unknown;
+  try {
+    normalized = normReq(args);
+  } catch {
+    return null;
+  }
+  if (!isRec(normalized) || typeof normalized.path !== "string") return null;
+  if (
+    typeof normalized.anchor !== "string" ||
+    (normalized.direction !== "before" && normalized.direction !== "after") ||
+    !Array.isArray(normalized.lines) ||
+    normalized.lines.some((line) => typeof line !== "string")
+  ) {
+    return null;
+  }
+  return {
+    path: normalized.path,
+    anchor: normalized.anchor,
+    direction: normalized.direction,
+    lines: normalized.lines,
+  };
+}
+
+type InsertToolDef = ToolDefinition<any, ReplaceDetails, RRState> & { renderShell?: "default" | "self" };
+
+export function buildInsertToolDef(): InsertToolDef {
+  return {
+    name: "insert",
+    label: "Insert",
+    description: loadP("../prompts/insert.md"),
+    promptSnippet: loadP("../prompts/insert-snippet.md"),
+    promptGuidelines: loadGuide("../prompts/insert-guidelines.md"),
+    prepareArguments: makePrepareArguments(),
+    parameters: insertToolSchema,
+    renderShell: "default",
+    renderCall: makeRenderCall(insertPreview, { getInput: getInsertInput, toolName: "insert" }),
+    renderResult(result, { isPartial }, theme, context) {
+      return renderEditResult(
+        result as {
+          content?: Array<{ type: string; text?: string }>;
+          details?: ReplaceDetails;
+        },
+        isPartial,
+        theme,
+        context,
+      );
+    },
+
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const canonical = normReq(params);
+      assertInsertReq(canonical);
+      const req = canonical;
+      const path = req.path;
+      const { ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor);
+      const absolutePath = toCwd(path, ctx.cwd);
+      const mutationTargetPath = await resolveTarget(absolutePath);
+      return withFileMutationQueue(mutationTargetPath, async () => {
+        abortIf(signal);
+        const preload = await readNormFile(path, ctx.cwd, {
+          signal,
+          accessMode: constants.R_OK | constants.W_OK,
+          maxLines: MAX_HASH_LINES,
+        });
+        const { editParams, anchorLine } = buildInsertEdit(req, preload, ref);
+        const pipe = await execPipeline(editParams, ctx.cwd, {
+          accessMode: constants.R_OK | constants.W_OK,
+          signal,
+          preloadedNorm: preload,
+          skipBoundaryDedup: true,
+        });
+        return commitEdit(pipe, {
+          path,
+          absolutePath,
+          mutationTargetPath,
+          signal,
+          verb: "inserted",
+          noopNoun: "Insertion",
+          foldedAnchorLines: anchorLine === undefined ? 0 : 1,
+          prefixWarnings: anchorWarnings,
+          onApplied: () => clearBoundaryBypass(mutationTargetPath),
+        });
+      });
+    },
+  };
+}
+
+export function regInsert(pi: ExtensionAPI): void {
+  pi.registerTool(buildInsertToolDef());
+}

package/src/replace-diff.ts

@@ -47,6 +47,10 @@ function fmtDiffLine(
   return `${prefix}${hash}${HASH_SEP}${line}`;
 }
 
+function isBlankLine(line: string): boolean {
+  return line.trim().length === 0;
+}
+
 const ELLIPSIS_MARKER: unique symbol = Symbol("ellipsis");
 const isEllipsisMarker = (line: string | symbol): line is symbol =>
   line === ELLIPSIS_MARKER;
@@ -99,15 +103,52 @@ export function genDiff(
       let skipTail = 0;
 
       if (!lastWasChange) {
-        skipStart = Math.max(0, displayLines.length - contextLines);
+        let count = contextLines;
+        if (
+          contextLines > 0 &&
+          displayLines.length > count &&
+          isBlankLine(displayLines[displayLines.length - 1]!)
+        ) {
+          count += 1;
+        }
+        count = Math.min(count, displayLines.length);
+        skipStart = displayLines.length - count;
         linesToShow = displayLines.slice(skipStart);
       } else if (nextPartIsChange && displayLines.length > contextLines * 2) {
-        const tail = displayLines.slice(-contextLines);
-        linesToShow = [...displayLines.slice(0, contextLines), ELLIPSIS_MARKER, ...tail];
-        skipMiddle = displayLines.length - contextLines * 2;
+        let headCount = contextLines;
+        let tailCount = contextLines;
+        if (
+          contextLines > 0 &&
+          displayLines.length - headCount > tailCount &&
+          isBlankLine(displayLines[headCount - 1]!)
+        ) {
+          headCount += 1;
+        }
+        if (
+          contextLines > 0 &&
+          displayLines.length - tailCount > headCount &&
+          isBlankLine(displayLines[displayLines.length - tailCount]!)
+        ) {
+          tailCount += 1;
+        }
+        const middleLen = displayLines.length - headCount - tailCount;
+        if (middleLen > 0) {
+          linesToShow = [
+            ...displayLines.slice(0, headCount),
+            ELLIPSIS_MARKER,
+            ...displayLines.slice(displayLines.length - tailCount),
+          ];
+          skipMiddle = middleLen;
+        } else {
+          linesToShow = displayLines;
+        }
       } else if (!nextPartIsChange && linesToShow.length > contextLines) {
-        linesToShow = linesToShow.slice(0, contextLines);
-        skipTail = displayLines.length - contextLines;
+        let count = contextLines;
+        const firstLine = linesToShow[0];
+        if (contextLines > 0 && typeof firstLine === "string" && isBlankLine(firstLine)) count += 1;
+        count = Math.min(count, linesToShow.length);
+        linesToShow = linesToShow.slice(0, count);
+        skipTail = displayLines.length - count;
       }
 
       if (skipStart > 0) {