pi-readseek 0.7.6 → 0.7.8

package/src/edit-diff.ts

@@ -1,359 +0,0 @@
-import * as Diff from "diff";
-import { computeLineHash } from "./hashline.js";
-import { CONFUSABLE_HYPHENS_RE } from "./confusable-hyphens.js";
-
-
-export function detectLineEnding(content: string): "\r\n" | "\n" {
-	let crlf = 0;
-	let lf = 0;
-	for (let i = 0; i < content.length; i++) {
-		if (content[i] === "\r" && i + 1 < content.length && content[i + 1] === "\n") {
-			crlf++;
-			i++;
-		} else if (content[i] === "\n") {
-			lf++;
-		}
-	}
-	if (lf === 0 && crlf === 0) return "\n";
-	if (lf === 0) return "\r\n";
-	if (crlf === 0) return "\n";
-	return crlf > lf ? "\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 };
-}
-
-/**
- * Detect bare \r characters that are NOT part of \r\n sequences.
- * These cause line-count mismatches between normalizeToLF and external tools (ripgrep, wc).
- */
-export function hasBareCarriageReturn(content: string): boolean {
-	return content.replace(/\r\n/g, "").includes("\r");
-}
-
-const SINGLE_QUOTES_RE = /[\u2018\u2019\u201A\u201B]/g;
-const DOUBLE_QUOTES_RE = /[\u201C\u201D\u201E\u201F]/g;
-const UNICODE_SPACES_RE = /[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g;
-
-function normalizeFuzzyChar(ch: string): string {
-	return ch.replace(SINGLE_QUOTES_RE, "'").replace(DOUBLE_QUOTES_RE, '"').replace(CONFUSABLE_HYPHENS_RE, "-").replace(UNICODE_SPACES_RE, " ");
-}
-
-function normalizeForFuzzyMatch(text: string): string {
-	return text
-		.split("\n")
-		.map((line) => line.trimEnd())
-		.join("\n")
-		.replace(SINGLE_QUOTES_RE, "'")
-		.replace(DOUBLE_QUOTES_RE, '"')
-		.replace(CONFUSABLE_HYPHENS_RE, "-")
-		.replace(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 type ReplaceTextResult = { content: string; count: number; usedFuzzyMatch: boolean };
-
-export function replaceText(
-	content: string,
-	oldText: string,
-	newText: string,
-	opts: { all?: boolean; fuzzy?: boolean },
-): ReplaceTextResult {
-	if (!oldText.length) return { content, count: 0, usedFuzzyMatch: false };
-	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, usedFuzzyMatch: false };
-		}
-		if (!opts.fuzzy) return { content, count: 0, usedFuzzyMatch: false };
-
-		const normalizedNeedle = normalizeForFuzzyMatch(oldText);
-		if (!normalizedNeedle.length) return { content, count: 0, usedFuzzyMatch: false };
-
-		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, usedFuzzyMatch: false };
-
-		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, usedFuzzyMatch: true };
-	}
-
-	const exactIndex = content.indexOf(oldText);
-	if (exactIndex !== -1) {
-		return {
-			content: content.substring(0, exactIndex) + normalizedNew + content.substring(exactIndex + oldText.length),
-			count: 1,
-			usedFuzzyMatch: false,
-		};
-	}
-
-	if (!opts.fuzzy) return { content, count: 0, usedFuzzyMatch: false };
-
-	const result = fuzzyFindText(content, oldText);
-	if (!result.found) return { content, count: 0, usedFuzzyMatch: false };
-
-	return {
-		content: content.substring(0, result.index) + normalizedNew + content.substring(result.index + result.matchLength),
-		count: 1,
-		usedFuzzyMatch: result.usedFuzzyMatch,
-	};
-}
-
-
-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(`+${String(newLineNum).padStart(lineNumWidth, " ")} ${line}`);
-					newLineNum++;
-				} else {
-					output.push(`-${String(oldLineNum).padStart(lineNumWidth, " ")} ${line}`);
-					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(` ${String(oldLineNum).padStart(lineNumWidth, " ")} ${line}`);
-				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 };
-}
-
-/**
- * Generate a compact diff for single-line edits, or fall back to the full diff.
- *
- * - Single-line replacement: `LINE:HASH|old → LINE:HASH|new`
- * - Single-line deletion: `LINE:HASH|old → [deleted]`
- * - Multi-line changes: full output from generateDiffString()
- */
-export function generateCompactOrFullDiff(
-	oldContent: string,
-	newContent: string,
-	contextLines = 4,
-): { diff: string; firstChangedLine: number | undefined } {
-	if (oldContent === newContent) return { diff: "", firstChangedLine: undefined };
-
-	const oldLines = oldContent.split("\n");
-	const newLines = newContent.split("\n");
-
-	// Case 1: Same line count, exactly one changed line → compact replacement.
-	if (oldLines.length === newLines.length) {
-		let changedIndex = -1;
-		let changeCount = 0;
-
-		for (let i = 0; i < oldLines.length; i++) {
-			if (oldLines[i] !== newLines[i]) {
-				changedIndex = i;
-				changeCount++;
-				if (changeCount > 1) break;
-			}
-		}
-
-		if (changeCount === 1 && changedIndex >= 0) {
-			const lineNum = changedIndex + 1;
-			const oldLine = oldLines[changedIndex] ?? "";
-			const newLine = newLines[changedIndex] ?? "";
-			const oldHash = computeLineHash(oldLine);
-			const newHash = computeLineHash(newLine);
-			return {
-				diff: `${lineNum}:${oldHash}|${oldLine} → ${lineNum}:${newHash}|${newLine}`,
-				firstChangedLine: lineNum,
-			};
-		}
-	}
-
-	// Case 2: Exactly one line deleted.
-	// old has one more line than new, and removing a single line makes them equal.
-	if (oldLines.length === newLines.length + 1) {
-		let deletedIndex = -1;
-		let j = 0;
-		let failed = false;
-
-		for (let i = 0; i < oldLines.length; i++) {
-			if (j < newLines.length && oldLines[i] === newLines[j]) {
-				j++;
-				continue;
-			}
-			if (deletedIndex === -1) {
-				deletedIndex = i;
-				continue;
-			}
-			failed = true;
-			break;
-		}
-
-		if (!failed && deletedIndex !== -1 && j === newLines.length) {
-			const lineNum = deletedIndex + 1;
-			const oldLine = oldLines[deletedIndex] ?? "";
-			const oldHash = computeLineHash(oldLine);
-			return {
-				diff: `${lineNum}:${oldHash}|${oldLine} → [deleted]`,
-				firstChangedLine: lineNum,
-			};
-		}
-	}
-
-	// Fall back to the full (existing) diff format.
-	return generateDiffString(oldContent, newContent, contextLines);
-}

package/src/edit-output.ts

@@ -1,110 +0,0 @@
-import { countEditTypes, parseDiffStats } from "./edit-render-helpers.js";
-import { buildReadSeekEditResult, type SemanticSummary } from "./readseek-value.js";
-
-import type { DiffData } from "./diff-data.js";
-export interface BuildEditOutputInput {
-  path: string;
-  displayPath: string;
-  diff: string;
-  patch?: string;
-  diffData?: DiffData;
-  firstChangedLine: number | undefined;
-  warnings: string[];
-  noopEdits: unknown[];
-  semanticSummary?: SemanticSummary;
-  edits?: unknown[];
-}
-export interface EditOutputResult {
-  text: string;
-  patch: string;
-  readSeekValue: ReturnType<typeof buildReadSeekEditResult>;
-}
-
-const EDIT_OPERATION_NAMES = ["set_line", "replace_lines", "insert_after", "replace"] as const;
-
-type EditOperationName = (typeof EDIT_OPERATION_NAMES)[number];
-
-type EditOperationWithNewText = {
-  new_text: string;
-};
-
-function hasNewText(value: unknown): value is EditOperationWithNewText {
-  return typeof value === "object" && value !== null && typeof (value as { new_text?: unknown }).new_text === "string";
-}
-
-function getVisibleDiffStats(diff: string): { added: number; removed: number } {
-  const stats = parseDiffStats(diff);
-  if (stats.added > 0 || stats.removed > 0) return stats;
-  if (!diff.includes("→")) return stats;
-  if (diff.includes("→ [deleted]")) return { added: 0, removed: 1 };
-  return { added: 1, removed: 1 };
-}
-function buildVisibleSummary(displayPath: string, diff: string, edits: unknown[] | undefined): string {
-  let stats = getVisibleDiffStats(diff);
-  const counts = countEditTypes(edits);
-  const editCount = counts.total || 1;
-
-  if (
-    counts.total > 0 &&
-    counts.insert_after === counts.total &&
-    stats.removed > 0 &&
-    stats.added === stats.removed + counts.insert_after
-  ) {
-    stats = { added: counts.insert_after, removed: 0 };
-  }
-
-  const changeWord = editCount === 1 ? "change" : "changes";
-  const changedLineCount = Math.max(stats.added, stats.removed);
-  const lineWord = changedLineCount === 1 ? "line" : "lines";
-  return `Edited ${displayPath} (${editCount} ${changeWord}, +${stats.added} -${stats.removed} ${lineWord})`;
-}
-function extractNewTextValues(edits: unknown[] | undefined): string[] {
-  const values: string[] = [];
-  for (const edit of edits ?? []) {
-    if (!edit || typeof edit !== "object") continue;
-
-    const operations = edit as Partial<Record<EditOperationName, unknown>>;
-    for (const operationName of EDIT_OPERATION_NAMES) {
-      const operation = operations[operationName];
-      if (hasNewText(operation)) values.push(operation.new_text);
-    }
-  }
-  return values;
-}
-function formatWhitespaceOnlyWarning(semanticSummary: SemanticSummary | undefined, edits: unknown[] | undefined): string | undefined {
-  if (semanticSummary?.classification !== "whitespace-only") return undefined;
-  if (!extractNewTextValues(edits).some((text) => /\S/.test(text))) return undefined;
-  return "⚠ Edit classified as whitespace-only — if you intended a behavior change, re-read to verify.";
-}
-function formatReplaceHint(edits: unknown[] | undefined, noopEdits: unknown[]): string | undefined {
-  if ((noopEdits ?? []).length > 0) return undefined;
-  const counts = countEditTypes(edits);
-  if (counts.replace === 0) return undefined;
-  if (counts.replace !== counts.total) return undefined;
-  return "[info: this edit used replace (unverified). For safer future edits, prefer set_line/replace_lines with an anchor from readSeek_read/readSeek_grep/readSeek_search.]";
-}
-export function buildEditOutput(input: BuildEditOutputInput): EditOutputResult {
-  const summary = `Updated ${input.displayPath}`;
-  const visibleSummary = buildVisibleSummary(input.displayPath, input.diff, input.edits);
-  const semanticWarning = formatWhitespaceOnlyWarning(input.semanticSummary, input.edits);
-  const warningText = input.warnings.length ? `\n\nWarnings:\n${input.warnings.join("\n")}` : "";
-  const replaceHint = formatReplaceHint(input.edits, input.noopEdits);
-  let text = visibleSummary;
-  if (semanticWarning) text += `\n${semanticWarning}`;
-  text += warningText;
-  if (replaceHint) text += `\n${replaceHint}`;
-  return {
-    text,
-    patch: input.patch ?? "",
-    readSeekValue: buildReadSeekEditResult({
-      path: input.path,
-      summary,
-      diff: input.diff,
-      ...(input.diffData ? { diffData: input.diffData } : {}),
-      firstChangedLine: input.firstChangedLine,
-      warnings: input.warnings,
-      noopEdits: input.noopEdits,
-      ...(input.semanticSummary ? { semanticSummary: input.semanticSummary } : {}),
-    }),
-  };
-}

package/src/edit-render-helpers.ts

@@ -1,141 +0,0 @@
-const VARIANT_KEYS = ["set_line", "replace_lines", "insert_after", "replace"] as const;
-
-export type EditTypeCounts = {
-  set_line: number;
-  replace_lines: number;
-  insert_after: number;
-  replace: number;
-  total: number;
-};
-
-export function countEditTypes(edits: unknown[] | undefined): EditTypeCounts {
-  const counts: EditTypeCounts = {
-    set_line: 0,
-    replace_lines: 0,
-    insert_after: 0,
-    replace: 0,
-    total: 0,
-  };
-  if (!edits) return counts;
-  for (const edit of edits) {
-    counts.total++;
-    if (edit && typeof edit === "object") {
-      for (const key of VARIANT_KEYS) {
-        if (key in edit) {
-          counts[key]++;
-          break;
-        }
-      }
-    }
-  }
-  return counts;
-}
-
-export interface DiffStats {
-  added: number;
-  removed: number;
-}
-
-export function parseDiffStats(diff: string | undefined): DiffStats {
-  if (!diff) return { added: 0, removed: 0 };
-  let added = 0;
-  let removed = 0;
-  for (const line of diff.split("\n")) {
-    if (line.startsWith("+++") || line.startsWith("---")) continue;
-    if (line.startsWith("+")) added++;
-    else if (line.startsWith("-")) removed++;
-  }
-  return { added, removed };
-}
-
-export interface EditCallTextResult {
-  path: string | null;
-  suffix: string | undefined;
-}
-
-export function formatEditCallText(
-  args: Record<string, unknown> | undefined,
-  argsComplete: boolean,
-): EditCallTextResult {
-  const rawPath = typeof args?.path === "string" ? args.path : null;
-
-  if (!argsComplete) {
-    return { path: rawPath, suffix: undefined };
-  }
-
-  const edits = args?.edits;
-  if (!Array.isArray(edits) || edits.length === 0) {
-    return { path: rawPath, suffix: undefined };
-  }
-
-  const counts = countEditTypes(edits);
-  const parts: string[] = [];
-  for (const key of VARIANT_KEYS) {
-    if (counts[key] > 0) {
-      parts.push(`${counts[key]} ${key}`);
-    }
-  }
-  const word = counts.total === 1 ? "edit" : "edits";
-  const suffix = `${counts.total} ${word} (${parts.join(", ")})`;
-  return { path: rawPath, suffix };
-}
-
-export interface EditResultTextInput {
-  isError: boolean;
-  diff: string;
-  warnings: string[];
-  noopEdits: unknown[];
-  errorText: string;
-  semanticClassification?: "no-op" | "whitespace-only" | "semantic" | "mixed";
-}
-
-export interface EditResultTextOutput {
-  diffStats: string | undefined;
-  noOp: boolean;
-  warningsBadge: string | undefined;
-  errorText: string | undefined;
-  semanticBadge: string | undefined;
-}
-
-export function formatEditResultText(input: EditResultTextInput): EditResultTextOutput {
-  const { isError, diff, warnings, noopEdits, errorText } = input;
-
-  // No-op detection: error + noopEdits present OR error text contains "No changes made"
-  const isNoOp = isError && (
-    (Array.isArray(noopEdits) && noopEdits.length > 0) ||
-    errorText.includes("No changes made")
-  );
-
-  // Diff stats
-  const stats = parseDiffStats(diff);
-  const hasDiffStats = stats.added > 0 || stats.removed > 0;
-  const diffStats = hasDiffStats ? `+${stats.added} / -${stats.removed}` : undefined;
-
-  // Warnings badge
-  let warningsBadge: string | undefined;
-  if (warnings.length === 1) {
-    warningsBadge = "\u26a0 1 warning";
-  } else if (warnings.length > 1) {
-    warningsBadge = `\u26a0 ${warnings.length} warnings`;
-  }
-
-  // Error text (only for errors)
-  const showErrorText = isError ? errorText : undefined;
-
-  // Semantic classification badge (success only)
-  let semanticBadge: string | undefined;
-  if (!isError && !isNoOp && input.semanticClassification) {
-    switch (input.semanticClassification) {
-      case "whitespace-only": semanticBadge = "ws-only"; break;
-      case "semantic": semanticBadge = "\u2713 semantic"; break;
-      case "mixed": semanticBadge = "mixed"; break;
-    }
-  }
-  return {
-    diffStats,
-    noOp: isNoOp,
-    warningsBadge,
-    errorText: showErrorText,
-    semanticBadge,
-  };
-}

package/src/edit-syntax-validate.ts

@@ -1,65 +0,0 @@
-import { readSeekCheck, type ReadSeekCheckOutput, type ReadSeekDiagnostic } from "./readseek-client.js";
-
-export interface ValidateInput {
-  filePath: string;
-  before: string | undefined;
-  after: string;
-}
-
-export interface ValidateResult {
-  errorLines: string[];
-  newErrorCount: number;
-  newMissingCount: number;
-}
-
-function dedupeSortLines(diagnostics: ReadSeekDiagnostic[]): string[] {
-  const seen = new Set<string>();
-  const out: Array<{ key: string; start: number }> = [];
-  for (const diagnostic of diagnostics) {
-    const key =
-      diagnostic.start_line === diagnostic.end_line
-        ? String(diagnostic.start_line)
-        : `${diagnostic.start_line}-${diagnostic.end_line}`;
-    if (!seen.has(key)) {
-      seen.add(key);
-      out.push({ key, start: diagnostic.start_line });
-    }
-  }
-  out.sort((a, b) => a.start - b.start);
-  return out.map((o) => o.key);
-}
-
-const EMPTY: ReadSeekCheckOutput = { errorCount: 0, missingCount: 0, diagnostics: [] };
-
-/**
- * Compare parse diagnostics between `before` and `after` and report any newly
- * introduced syntax errors. Uses readseek's native `check`, so every language
- * with a tree-sitter parser is validated.
- *
- * Returns `null` when nothing new appears or when readseek cannot parse the
- * file, so a validator failure never blocks an edit.
- */
-export async function validateSyntaxRegression(
-  input: ValidateInput,
-  options: { signal?: AbortSignal } = {},
-): Promise<ValidateResult | null> {
-  let before: ReadSeekCheckOutput;
-  let after: ReadSeekCheckOutput;
-  try {
-    before = input.before === undefined ? EMPTY : await readSeekCheck(input.filePath, input.before, { signal: options.signal });
-    after = await readSeekCheck(input.filePath, input.after, { signal: options.signal });
-  } catch {
-    return null;
-  }
-
-  const newErrorCount = Math.max(0, after.errorCount - before.errorCount);
-  const newMissingCount = Math.max(0, after.missingCount - before.missingCount);
-
-  if (newErrorCount === 0 && newMissingCount === 0) return null;
-
-  return {
-    errorLines: dedupeSortLines(after.diagnostics),
-    newErrorCount,
-    newMissingCount,
-  };
-}