@claudiu-ceia/spatch 0.3.0 → 0.3.1

package/dist/command.js

@@ -1,143 +1,58 @@
-import { readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { stderr as processStderr, stdin as processStdin, stdout as processStdout, } from "node:process";
-import { createInterface } from "node:readline/promises";
+import { stderr as processStderr, stdin as processStdin } from "node:process";
 import { buildCommand } from "@stricli/core";
-import chalk, { Chalk } from "chalk";
 import { resolveTextInput } from "@claudiu-ceia/astkit-core";
+import { patchCommandFlagParameters, validatePatchCommandFlags, } from "./command/flags.js";
+import { runInteractivePatchCommand } from "./command/interactive.js";
+import { formatPatchOutput } from "./command/output.js";
 import { patchProject } from "./spatch.js";
 export async function runPatchCommand(patchInput, scope, flags, options = {}) {
+    validatePatchCommandFlags(flags);
     const patchScope = scope ?? ".";
     const patchCwd = flags.cwd;
+    const logger = options.logger ??
+        (flags.verbose ? (line) => processStderr.write(`${line}\n`) : undefined);
     const resolvedPatchInput = await resolvePatchInput(patchInput, {
         cwd: patchCwd,
         encoding: "utf8",
         readStdin: options.readStdin,
+        stdinStream: options.stdinStream,
     });
-    if (flags.interactive ?? false) {
-        if (flags["dry-run"] ?? false) {
-            throw new Error("Cannot combine --interactive with --dry-run.");
-        }
-        return runInteractivePatchCommand(resolvedPatchInput, patchScope, patchCwd, flags["no-color"] ?? false, options.interactiveDecider);
-    }
-    return patchProject(resolvedPatchInput, {
+    const patchOptions = {
         concurrency: flags.concurrency,
         cwd: patchCwd,
-        dryRun: flags["dry-run"] ?? false,
+        encoding: options.encoding,
+        logger,
         scope: patchScope,
         verbose: flags.verbose,
-        logger: flags.verbose ? (line) => processStderr.write(`${line}\n`) : undefined,
-    });
-}
-export function formatPatchOutput(result, options = {}) {
-    const chalkInstance = buildChalk(options);
-    const useColor = chalkInstance.level > 0;
-    const lines = [];
-    const changedFiles = result.files.filter((file) => file.replacementCount > 0);
-    for (const file of changedFiles) {
-        const headerPrefix = useColor ? chalkInstance.bold : (value) => value;
-        lines.push(headerPrefix(`diff --git a/${file.file} b/${file.file}`));
-        lines.push(useColor ? chalkInstance.gray(`--- a/${file.file}`) : `--- a/${file.file}`);
-        lines.push(useColor ? chalkInstance.gray(`+++ b/${file.file}`) : `+++ b/${file.file}`);
-        for (const occurrence of file.occurrences) {
-            if (occurrence.matched === occurrence.replacement) {
-                continue;
-            }
-            const oldCount = countLines(occurrence.matched);
-            const newCount = countLines(occurrence.replacement);
-            const hunkHeader = `@@ -${occurrence.line},${oldCount} +${occurrence.line},${newCount} @@`;
-            lines.push(useColor ? chalkInstance.cyan(hunkHeader) : hunkHeader);
-            for (const oldLine of splitDiffLines(occurrence.matched)) {
-                const line = `-${oldLine}`;
-                lines.push(useColor ? chalkInstance.red(line) : line);
-            }
-            for (const newLine of splitDiffLines(occurrence.replacement)) {
-                const line = `+${newLine}`;
-                lines.push(useColor ? chalkInstance.green(line) : line);
-            }
-        }
-    }
-    if (changedFiles.length === 0) {
-        lines.push(useColor ? chalkInstance.gray("No changes.") : "No changes.");
+    };
+    if (flags.interactive ?? false) {
+        return runInteractivePatchCommand(resolvedPatchInput, {
+            ...patchOptions,
+            noColor: flags["no-color"] ?? false,
+            interactiveDecider: options.interactiveDecider,
+        });
     }
-    const summary = [
-        `${result.filesChanged} ${pluralize("file", result.filesChanged)} changed`,
-        `${result.totalReplacements} ${pluralize("replacement", result.totalReplacements)}`,
-        result.dryRun ? "(dry-run)" : null,
-    ]
-        .filter((part) => part !== null)
-        .join(", ");
-    lines.push(useColor ? chalkInstance.gray(summary) : summary);
-    return lines.join("\n");
+    return patchProject(resolvedPatchInput, {
+        ...patchOptions,
+        dryRun: (flags["dry-run"] ?? false) || (flags.check ?? false),
+    });
 }
 export const patchCommand = buildCommand({
     async func(flags, patchInput, scope) {
         const result = await runPatchCommand(patchInput, scope, flags);
         if (flags.json ?? false) {
             this.process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+            enforceCheckMode(flags, result);
             return;
         }
         const output = formatPatchOutput(result, {
-            color: Boolean(processStdout.isTTY) && !(flags["no-color"] ?? false),
+            color: Boolean(this.process.stdout.isTTY) && !(flags["no-color"] ?? false),
         });
         this.process.stdout.write(`${output}\n`);
+        enforceCheckMode(flags, result);
     },
     parameters: {
-        flags: {
-            concurrency: {
-                kind: "parsed",
-                optional: true,
-                brief: "Max files processed concurrently (default: 8)",
-                placeholder: "n",
-                parse: (input) => {
-                    const value = Number(input);
-                    if (!Number.isFinite(value) || value <= 0) {
-                        throw new Error("--concurrency must be a positive number");
-                    }
-                    return Math.floor(value);
-                },
-            },
-            verbose: {
-                kind: "parsed",
-                optional: true,
-                brief: "Print perf tracing (1=summary, 2=includes slow files)",
-                placeholder: "level",
-                parse: (input) => {
-                    const value = Number(input);
-                    if (!Number.isFinite(value) || value < 0) {
-                        throw new Error("--verbose must be a non-negative number");
-                    }
-                    return Math.floor(value);
-                },
-            },
-            interactive: {
-                kind: "boolean",
-                optional: true,
-                brief: "Interactively select which matches to apply",
-            },
-            json: {
-                kind: "boolean",
-                optional: true,
-                brief: "Output structured JSON instead of compact diff-style text",
-            },
-            "no-color": {
-                kind: "boolean",
-                optional: true,
-                brief: "Disable colored output",
-            },
-            "dry-run": {
-                kind: "boolean",
-                optional: true,
-                brief: "Preview changes without writing files",
-            },
-            cwd: {
-                kind: "parsed",
-                optional: true,
-                brief: "Working directory for resolving patch file and scope",
-                placeholder: "path",
-                parse: (input) => input,
-            },
-        },
+        flags: patchCommandFlagParameters,
         positional: {
             kind: "tuple",
             parameters: [
@@ -159,244 +74,31 @@ export const patchCommand = buildCommand({
         brief: "Apply structural rewrite from a patch document",
     },
 });
-function buildChalk(options) {
-    if (options.chalkInstance) {
-        return options.chalkInstance;
-    }
-    const shouldColor = options.color ?? false;
-    if (!shouldColor) {
-        return new Chalk({ level: 0 });
-    }
-    const level = chalk.level > 0 ? chalk.level : 1;
-    return new Chalk({ level });
-}
-function splitDiffLines(text) {
-    const normalized = text.replaceAll("\r\n", "\n");
-    if (normalized.length === 0) {
-        return [""];
+function enforceCheckMode(flags, result) {
+    if (!(flags.check ?? false)) {
+        return;
     }
-    return normalized.split("\n");
-}
-function countLines(text) {
-    const normalized = text.replaceAll("\r\n", "\n");
-    if (normalized.length === 0) {
-        return 0;
+    if (result.totalReplacements > 0) {
+        throw new Error(`Check failed: ${result.totalReplacements} replacements would be applied in ${result.filesChanged} files.`);
     }
-    return normalized.split("\n").length;
-}
-function pluralize(word, count) {
-    return count === 1 ? word : `${word}s`;
-}
-async function runInteractivePatchCommand(patchInput, scope, cwd, noColor, interactiveDecider) {
-    if (!interactiveDecider && (!processStdin.isTTY || !processStdout.isTTY)) {
-        throw new Error("Interactive mode requires a TTY stdin/stdout.");
-    }
-    const startedAt = Date.now();
-    const dryResult = await patchProject(patchInput, {
-        cwd,
-        dryRun: true,
-        scope,
-    });
-    const totalChanges = dryResult.files.reduce((count, file) => count +
-        file.occurrences.filter((occurrence) => occurrence.matched !== occurrence.replacement).length, 0);
-    let interactivePrompt = null;
-    const decider = interactiveDecider ??
-        ((interactivePrompt = await createTerminalInteractiveDecider(noColor)),
-            interactivePrompt.decider);
-    const selectedByFile = new Map();
-    let applyAll = false;
-    let stop = false;
-    let changeNumber = 0;
-    try {
-        for (const file of dryResult.files) {
-            const selected = [];
-            for (const occurrence of file.occurrences) {
-                if (occurrence.matched === occurrence.replacement) {
-                    continue;
-                }
-                changeNumber += 1;
-                if (applyAll) {
-                    selected.push(occurrence);
-                    continue;
-                }
-                const choice = await decider({
-                    file: file.file,
-                    occurrence,
-                    changeNumber,
-                    totalChanges,
-                });
-                if (choice === "yes") {
-                    selected.push(occurrence);
-                    continue;
-                }
-                if (choice === "all") {
-                    applyAll = true;
-                    selected.push(occurrence);
-                    continue;
-                }
-                if (choice === "quit") {
-                    stop = true;
-                    break;
-                }
-            }
-            selectedByFile.set(file.file, selected);
-            if (stop) {
-                break;
-            }
-        }
-    }
-    finally {
-        interactivePrompt?.close();
-    }
-    const fileResults = [];
-    let filesChanged = 0;
-    let totalReplacements = 0;
-    for (const file of dryResult.files) {
-        const selected = selectedByFile.get(file.file) ?? [];
-        if (selected.length === 0) {
-            fileResults.push({
-                ...file,
-                replacementCount: 0,
-                changed: false,
-                byteDelta: 0,
-                occurrences: [],
-            });
-            continue;
-        }
-        const absolutePath = path.resolve(cwd ?? process.cwd(), file.file);
-        const originalText = await readFile(absolutePath, "utf8");
-        const rewrittenText = applySelectedOccurrences(originalText, selected);
-        const changed = rewrittenText !== originalText;
-        if (changed) {
-            await writeFile(absolutePath, rewrittenText, "utf8");
-        }
-        const replacementCount = selected.filter((occurrence) => occurrence.matched !== occurrence.replacement).length;
-        totalReplacements += replacementCount;
-        if (changed) {
-            filesChanged += 1;
-        }
-        fileResults.push({
-            ...file,
-            replacementCount,
-            changed,
-            byteDelta: changed
-                ? Buffer.byteLength(rewrittenText, "utf8") -
-                    Buffer.byteLength(originalText, "utf8")
-                : 0,
-            occurrences: selected,
-        });
-    }
-    return {
-        ...dryResult,
-        dryRun: false,
-        filesChanged,
-        totalReplacements,
-        elapsedMs: Date.now() - startedAt,
-        files: fileResults,
-    };
 }
 async function resolvePatchInput(patchInput, options) {
     if (patchInput !== "-") {
         return await resolveTextInput(patchInput, { cwd: options.cwd, encoding: options.encoding });
     }
-    const reader = options.readStdin ?? (() => readAllFromStdin(options.encoding));
+    const reader = options.readStdin ??
+        (() => readAllFromStream(options.stdinStream ?? processStdin, options.encoding));
     const text = await reader();
     if (text.length === 0) {
         throw new Error("Patch document read from stdin was empty.");
     }
     return text;
 }
-async function readAllFromStdin(encoding) {
-    // Read raw patch document from stdin (e.g. `cat rule.spatch | spatch - src`).
-    // `node:process` stdin is a stream in both Node and Bun.
-    const stdin = processStdin;
-    stdin.setEncoding(encoding);
+async function readAllFromStream(stream, encoding) {
+    stream.setEncoding?.(encoding);
     let text = "";
-    for await (const chunk of stdin) {
+    for await (const chunk of stream) {
         text += String(chunk);
     }
     return text;
 }
-function applySelectedOccurrences(source, occurrences) {
-    if (occurrences.length === 0) {
-        return source;
-    }
-    const sorted = [...occurrences].sort((left, right) => left.start - right.start);
-    const parts = [];
-    let cursor = 0;
-    for (const occurrence of sorted) {
-        parts.push(source.slice(cursor, occurrence.start));
-        parts.push(occurrence.replacement);
-        cursor = occurrence.end;
-    }
-    parts.push(source.slice(cursor));
-    return parts.join("");
-}
-async function createTerminalInteractiveDecider(noColor) {
-    const chalkInstance = buildChalk({
-        color: processStdout.isTTY && !noColor,
-    });
-    const useColor = chalkInstance.level > 0;
-    const rl = createInterface({
-        input: processStdin,
-        output: processStdout,
-    });
-    return {
-        decider: async ({ file, occurrence, changeNumber, totalChanges }) => {
-            processStdout.write(`\n${formatInteractiveChangeBlock({ file, occurrence, changeNumber, totalChanges }, {
-                chalkInstance,
-                color: useColor,
-            })}\n`);
-            while (true) {
-                const answer = await rl.question(useColor
-                    ? chalkInstance.bold("Choice [y/n/a/q] (default: n): ")
-                    : "Choice [y/n/a/q] (default: n): ");
-                const parsed = parseInteractiveChoice(answer);
-                if (parsed) {
-                    return parsed;
-                }
-                processStdout.write(useColor
-                    ? `${chalkInstance.yellow("Invalid choice.")} Use y, n, a, or q.\n`
-                    : "Invalid choice. Use y, n, a, or q.\n");
-            }
-        },
-        close: () => rl.close(),
-    };
-}
-function formatInteractiveChangeBlock(ctx, options = {}) {
-    const chalkInstance = buildChalk(options);
-    const useColor = chalkInstance.level > 0;
-    const divider = "─".repeat(72);
-    const oldCount = countLines(ctx.occurrence.matched);
-    const newCount = countLines(ctx.occurrence.replacement);
-    const hunkHeader = `@@ -${ctx.occurrence.line},${oldCount} +${ctx.occurrence.line},${newCount} @@`;
-    const lines = [
-        useColor ? chalkInstance.gray(divider) : divider,
-        useColor
-            ? chalkInstance.bold(`Change ${ctx.changeNumber}/${ctx.totalChanges} · ${ctx.file}:${ctx.occurrence.line}:${ctx.occurrence.character}`)
-            : `Change ${ctx.changeNumber}/${ctx.totalChanges} · ${ctx.file}:${ctx.occurrence.line}:${ctx.occurrence.character}`,
-        useColor ? chalkInstance.cyan(hunkHeader) : hunkHeader,
-        ...splitDiffLines(ctx.occurrence.matched).map((line) => useColor ? chalkInstance.red(`-${line}`) : `-${line}`),
-        ...splitDiffLines(ctx.occurrence.replacement).map((line) => useColor ? chalkInstance.green(`+${line}`) : `+${line}`),
-        useColor
-            ? chalkInstance.gray("Actions: [y] apply · [n] skip · [a] apply remaining · [q] quit")
-            : "Actions: [y] apply · [n] skip · [a] apply remaining · [q] quit",
-    ];
-    return lines.join("\n");
-}
-function parseInteractiveChoice(answer) {
-    const normalized = answer.trim().toLowerCase();
-    if (normalized.length === 0 || normalized === "n" || normalized === "no") {
-        return "no";
-    }
-    if (normalized === "y" || normalized === "yes") {
-        return "yes";
-    }
-    if (normalized === "a" || normalized === "all") {
-        return "all";
-    }
-    if (normalized === "q" || normalized === "quit") {
-        return "quit";
-    }
-    return null;
-}

package/dist/file-write.d.ts

@@ -0,0 +1,24 @@
+type WriteFileIfUnchangedAtomicallyInput = {
+    filePath: string;
+    originalText: string;
+    rewrittenText: string;
+    encoding: BufferEncoding;
+    operationName: string;
+    fs?: FileWriteFs;
+};
+type FileWriteFs = {
+    readFile: (path: string, encoding: BufferEncoding) => Promise<string>;
+    stat: (path: string) => Promise<{
+        mode: number;
+    }>;
+    writeFile: (path: string, data: string, options: {
+        encoding: BufferEncoding;
+        mode: number;
+    }) => Promise<void>;
+    rename: (oldPath: string, newPath: string) => Promise<void>;
+    rm: (path: string, options: {
+        force: boolean;
+    }) => Promise<void>;
+};
+export declare function writeFileIfUnchangedAtomically(input: WriteFileIfUnchangedAtomicallyInput): Promise<void>;
+export {};

package/dist/file-write.js

@@ -0,0 +1,50 @@
+import { randomUUID } from "node:crypto";
+import { readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+const defaultFs = {
+    readFile,
+    stat,
+    writeFile,
+    rename,
+    rm,
+};
+export async function writeFileIfUnchangedAtomically(input) {
+    const fs = input.fs ?? defaultFs;
+    let currentText;
+    try {
+        currentText = await fs.readFile(input.filePath, input.encoding);
+    }
+    catch {
+        throw buildStaleApplyError(input.filePath, input.operationName);
+    }
+    if (currentText !== input.originalText) {
+        throw buildStaleApplyError(input.filePath, input.operationName);
+    }
+    let fileStats;
+    try {
+        fileStats = await fs.stat(input.filePath);
+    }
+    catch {
+        throw buildStaleApplyError(input.filePath, input.operationName);
+    }
+    const tempPath = buildAtomicTempPath(input.filePath);
+    await fs.writeFile(tempPath, input.rewrittenText, {
+        encoding: input.encoding,
+        mode: fileStats.mode,
+    });
+    try {
+        await fs.rename(tempPath, input.filePath);
+    }
+    catch (error) {
+        await fs.rm(tempPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+function buildAtomicTempPath(filePath) {
+    const directory = path.dirname(filePath);
+    const fileName = path.basename(filePath);
+    return path.join(directory, `.${fileName}.spatch-${process.pid}-${randomUUID()}.tmp`);
+}
+function buildStaleApplyError(filePath, operationName) {
+    return new Error(`File changed during ${operationName}: ${filePath}. Re-run spatch to avoid overwriting concurrent edits.`);
+}

package/dist/index.d.ts

@@ -1,5 +1,3 @@
-export { patchProject, spatch, } from "./spatch.ts";
-export type { SpatchFileResult, SpatchOccurrence, SpatchOptions, SpatchResult, } from "./types.ts";
-export { DEFAULT_EXCLUDED_DIRECTORIES, DEFAULT_PATCHABLE_EXTENSIONS, } from "./types.ts";
-export { formatPatchOutput, patchCommand, runPatchCommand, } from "./command.ts";
-export type { PatchCommandFlags } from "./command.ts";
+export { patchProject } from "./spatch.ts";
+export type { SpatchFileResult, SpatchOccurrence, SpatchOptions, SpatchResult } from "./types.ts";
+export { DEFAULT_EXCLUDED_DIRECTORIES, DEFAULT_PATCHABLE_EXTENSIONS } from "./types.ts";

package/dist/index.js

@@ -1,3 +1,2 @@
-export { patchProject, spatch, } from "./spatch.js";
-export { DEFAULT_EXCLUDED_DIRECTORIES, DEFAULT_PATCHABLE_EXTENSIONS, } from "./types.js";
-export { formatPatchOutput, patchCommand, runPatchCommand, } from "./command.js";
+export { patchProject } from "./spatch.js";
+export { DEFAULT_EXCLUDED_DIRECTORIES, DEFAULT_PATCHABLE_EXTENSIONS } from "./types.js";

package/dist/internal/command.d.ts

@@ -0,0 +1 @@
+export { patchCommand } from "../command.ts";

package/dist/internal/command.js

@@ -0,0 +1 @@
+export { patchCommand } from "../command.js";

package/dist/phases/output.d.ts

@@ -1,9 +1,10 @@
 import type { SpatchResult } from "../types.ts";
 import type { ParsedPatchSpec } from "./parse.ts";
 import type { RewritePhaseResult } from "./rewrite.ts";
-export type OutputPhaseInput = {
+type OutputPhaseInput = {
     patch: ParsedPatchSpec;
     rewrite: RewritePhaseResult;
     elapsedMs: number;
 };
 export declare function buildSpatchResult(input: OutputPhaseInput): SpatchResult;
+export {};

package/dist/phases/parse.d.ts

@@ -3,9 +3,9 @@ export type ParsedPatchSpec = {
     pattern: string;
     replacement: string;
 };
-export type ParsedPatchInvocation = {
+type ParsedPatchInvocation = {
     patch: ParsedPatchSpec;
     options: SpatchOptions;
 };
-export declare function parsePatchSpec(patchDocument: string): ParsedPatchSpec;
 export declare function parsePatchInvocation(patchInput: string, options?: SpatchOptions): Promise<ParsedPatchInvocation>;
+export {};

package/dist/phases/parse.js

@@ -1,6 +1,6 @@
-import { resolveTextInput } from "@claudiu-ceia/astkit-core";
-import { parsePatchDocument } from "../patch-document.js";
-export function parsePatchSpec(patchDocument) {
+import { parseTextInvocation } from "@claudiu-ceia/astkit-core";
+import { parsePatchDocument } from "./patch-document.js";
+function parsePatchSpec(patchDocument) {
     const parsed = parsePatchDocument(patchDocument);
     return {
         pattern: parsed.pattern,
@@ -8,9 +8,9 @@ export function parsePatchSpec(patchDocument) {
     };
 }
 export async function parsePatchInvocation(patchInput, options = {}) {
-    const patchDocument = await resolveTextInput(patchInput, options);
+    const invocation = await parseTextInvocation(patchInput, options, parsePatchSpec);
     return {
-        patch: parsePatchSpec(patchDocument),
-        options,
+        patch: invocation.spec,
+        options: invocation.options,
     };
 }

package/dist/phases/patch-document.d.ts

@@ -0,0 +1,6 @@
+type ParsedPatchDocument = {
+    pattern: string;
+    replacement: string;
+};
+export declare function parsePatchDocument(source: string): ParsedPatchDocument;
+export {};

package/dist/{patch-document.js → phases/patch-document.js}

@@ -8,10 +8,7 @@ const additionLineParser = map(seq(str("+"), lineContentParser), ([, content]) =
 const deletionLineParser = map(seq(str("-"), lineContentParser), ([, content]) => ({ kind: "deletion", value: content }));
 const contextLineParser = map(lineContentParser, (content) => ({ kind: "context", value: content }));
 const patchLineParser = any(escapedMarkerLineParser, additionLineParser, deletionLineParser, contextLineParser);
-const patchDocumentParser = map(seq(patchLineParser, many(map(seq(str("\n"), patchLineParser), ([, line]) => line)), optional(str("\n")), eof()), ([firstLine, remainingLines, trailingNewline]) => ({
-    lines: [firstLine, ...remainingLines],
-    trailingNewline: trailingNewline !== null,
-}));
+const patchDocumentParser = map(seq(patchLineParser, many(map(seq(str("\n"), patchLineParser), ([, line]) => line)), optional(str("\n")), eof()), ([firstLine, remainingLines]) => [firstLine, ...remainingLines]);
 export function parsePatchDocument(source) {
     if (source.length === 0) {
         throw new Error("Patch document cannot be empty.");
@@ -23,21 +20,19 @@ export function parsePatchDocument(source) {
         throw new Error(`Invalid patch document: ${formatErrorCompact(parsed)}`);
     }
     const lines = trailingNewline &&
-        parsed.value.lines.length > 0 &&
-        parsed.value.lines[parsed.value.lines.length - 1]?.kind === "context" &&
-        parsed.value.lines[parsed.value.lines.length - 1]?.value === ""
-        ? parsed.value.lines.slice(0, -1)
-        : parsed.value.lines;
+        parsed.value.length > 0 &&
+        parsed.value[parsed.value.length - 1]?.kind === "context" &&
+        parsed.value[parsed.value.length - 1]?.value === ""
+        ? parsed.value.slice(0, -1)
+        : parsed.value;
     const patternLines = [];
     const replacementLines = [];
     let additions = 0;
     let deletions = 0;
-    let contextLines = 0;
     for (const line of lines) {
         if (line.kind === "context") {
             patternLines.push(line.value);
             replacementLines.push(line.value);
-            contextLines += 1;
             continue;
         }
         if (line.kind === "addition") {
@@ -56,9 +51,5 @@ export function parsePatchDocument(source) {
     return {
         pattern: trailingNewline ? `${pattern}\n` : pattern,
         replacement: trailingNewline ? `${replacement}\n` : replacement,
-        additions,
-        deletions,
-        contextLines,
-        trailingNewline,
     };
 }