@claudiu-ceia/spatch 0.2.0 → 0.3.1

package/dist/command/interactive/path-resolution.js

@@ -0,0 +1,55 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+export async function resolveInteractiveFilePath(file, options) {
+    if (path.isAbsolute(file)) {
+        const absolute = path.resolve(file);
+        if (isCandidateInScope(absolute, options)) {
+            return absolute;
+        }
+        throw new Error(`Resolved interactive file is outside selected scope: ${file}`);
+    }
+    const candidates = new Set();
+    if (options.scopeKind === "file") {
+        candidates.add(options.scope);
+        candidates.add(path.resolve(path.dirname(options.scope), file));
+    }
+    else {
+        candidates.add(path.resolve(options.scope, file));
+    }
+    candidates.add(path.resolve(options.cwd, file));
+    const resolvedCandidates = [];
+    for (const candidate of candidates) {
+        if (!isCandidateInScope(candidate, options)) {
+            continue;
+        }
+        try {
+            const candidateStats = await stat(candidate);
+            if (candidateStats.isFile()) {
+                resolvedCandidates.push(candidate);
+            }
+        }
+        catch {
+            // Try next candidate.
+        }
+    }
+    if (resolvedCandidates.length === 1) {
+        return resolvedCandidates[0];
+    }
+    if (resolvedCandidates.length > 1) {
+        throw new Error(`Ambiguous interactive patch target file: ${file}. Re-run spatch interactive with a narrower scope.`);
+    }
+    throw new Error(`Unable to resolve interactive patch target file: ${file}. Re-run spatch interactive.`);
+}
+function isCandidateInScope(candidate, options) {
+    if (options.scopeKind === "file") {
+        return path.resolve(candidate) === options.scope;
+    }
+    const relative = path.relative(options.scope, candidate);
+    if (relative.length === 0) {
+        return true;
+    }
+    if (path.isAbsolute(relative)) {
+        return false;
+    }
+    return relative !== ".." && !relative.startsWith(`..${path.sep}`);
+}

package/dist/command/interactive/run.d.ts

@@ -0,0 +1,3 @@
+import type { SpatchResult } from "../../types.ts";
+import type { RunInteractivePatchCommandOptions } from "./types.ts";
+export declare function runInteractivePatchCommand(patchInput: string, options: RunInteractivePatchCommandOptions): Promise<SpatchResult>;

package/dist/command/interactive/run.js

@@ -0,0 +1,166 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+import { writeFileIfUnchangedAtomically } from "../../file-write.js";
+import { applyReplacementSpans } from "../../replacement-spans.js";
+import { patchProject } from "../../spatch.js";
+import { resolveInteractiveFilePath } from "./path-resolution.js";
+import { createTerminalInteractiveDecider } from "./terminal.js";
+import { validateSelectedOccurrences } from "./validation.js";
+export async function runInteractivePatchCommand(patchInput, options) {
+    const scope = options.scope ?? ".";
+    const cwd = options.cwd;
+    const resolvedCwd = path.resolve(cwd ?? process.cwd());
+    const resolvedScope = path.resolve(resolvedCwd, scope);
+    const resolvedScopeStats = await stat(resolvedScope);
+    const scopeKind = resolvedScopeStats.isFile()
+        ? "file"
+        : resolvedScopeStats.isDirectory()
+            ? "directory"
+            : (() => {
+                throw new Error(`Scope must resolve to a file or directory: ${resolvedScope}`);
+            })();
+    const encoding = options.encoding ?? "utf8";
+    const noColor = options.noColor;
+    const interactiveDecider = options.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, {
+        concurrency: options.concurrency,
+        cwd,
+        dryRun: true,
+        encoding: options.encoding,
+        logger: options.logger,
+        scope,
+        verbose: options.verbose,
+    });
+    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;
+    const preparedByFile = new Map();
+    for (const file of dryResult.files) {
+        const selected = selectedByFile.get(file.file) ?? [];
+        if (selected.length === 0) {
+            continue;
+        }
+        const absolutePath = await resolveInteractiveFilePath(file.file, {
+            cwd: resolvedCwd,
+            scope: resolvedScope,
+            scopeKind,
+        });
+        const originalText = await readFile(absolutePath, encoding);
+        validateSelectedOccurrences(file.file, originalText, selected);
+        const rewrittenText = applyReplacementSpans(originalText, selected);
+        const changed = rewrittenText !== originalText;
+        const replacementCount = selected.filter((occurrence) => occurrence.matched !== occurrence.replacement).length;
+        preparedByFile.set(file.file, {
+            absolutePath,
+            originalText,
+            rewrittenText,
+            changed,
+            replacementCount,
+            selected,
+        });
+    }
+    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 prepared = preparedByFile.get(file.file);
+        if (!prepared) {
+            throw new Error(`Missing prepared interactive rewrite state for ${file.file}`);
+        }
+        if (prepared.changed) {
+            await writeFileIfUnchangedAtomically({
+                filePath: prepared.absolutePath,
+                originalText: prepared.originalText,
+                rewrittenText: prepared.rewrittenText,
+                encoding,
+                operationName: "interactive patch apply",
+            });
+        }
+        fileResults.push({
+            ...file,
+            replacementCount: prepared.replacementCount,
+            changed: prepared.changed,
+            byteDelta: prepared.changed
+                ? Buffer.byteLength(prepared.rewrittenText, encoding) -
+                    Buffer.byteLength(prepared.originalText, encoding)
+                : 0,
+            occurrences: prepared.selected,
+        });
+        totalReplacements += prepared.replacementCount;
+        if (prepared.changed) {
+            filesChanged += 1;
+        }
+    }
+    return {
+        ...dryResult,
+        dryRun: false,
+        filesChanged,
+        totalReplacements,
+        elapsedMs: Date.now() - startedAt,
+        files: fileResults,
+    };
+}

package/dist/command/interactive/terminal.d.ts

@@ -0,0 +1,32 @@
+import type { Readable, Writable } from "node:stream";
+import { type FormatPatchOutputOptions } from "../output.ts";
+import type { InteractiveChoice, InteractiveContext, InteractiveDecider } from "./types.ts";
+type PromptInterface = {
+    question(prompt: string): Promise<string>;
+    close(): void;
+};
+type TerminalInteractiveDependencies = {
+    stdin: Readable & {
+        isTTY?: boolean;
+    };
+    stdout: Writable & {
+        isTTY?: boolean;
+        write(chunk: string): boolean;
+    };
+    createPrompt: (options: {
+        input: Readable & {
+            isTTY?: boolean;
+        };
+        output: Writable & {
+            isTTY?: boolean;
+            write(chunk: string): boolean;
+        };
+    }) => PromptInterface;
+};
+export declare function createTerminalInteractiveDecider(noColor: boolean, dependencies?: TerminalInteractiveDependencies): Promise<{
+    decider: InteractiveDecider;
+    close: () => void;
+}>;
+export declare function formatInteractiveChangeBlock(ctx: InteractiveContext, options?: FormatPatchOutputOptions): string;
+export declare function parseInteractiveChoice(answer: string): InteractiveChoice | null;
+export {};

package/dist/command/interactive/terminal.js

@@ -0,0 +1,79 @@
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+import { buildChalk, countLines, escapeTerminalText, splitDiffLines, } from "../output.js";
+const defaultTerminalInteractiveDependencies = {
+    stdin: processStdin,
+    stdout: processStdout,
+    createPrompt: ({ input, output }) => createInterface({ input, output }),
+};
+export async function createTerminalInteractiveDecider(noColor, dependencies = defaultTerminalInteractiveDependencies) {
+    const chalkInstance = buildChalk({
+        color: Boolean(dependencies.stdout.isTTY) && !noColor,
+    });
+    const useColor = chalkInstance.level > 0;
+    const rl = dependencies.createPrompt({
+        input: dependencies.stdin,
+        output: dependencies.stdout,
+    });
+    return {
+        decider: async ({ file, occurrence, changeNumber, totalChanges }) => {
+            dependencies.stdout.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;
+                }
+                dependencies.stdout.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(),
+    };
+}
+export function formatInteractiveChangeBlock(ctx, options = {}) {
+    const chalkInstance = buildChalk(options);
+    const useColor = chalkInstance.level > 0;
+    const safeFile = escapeTerminalText(ctx.file);
+    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} · ${safeFile}:${ctx.occurrence.line}:${ctx.occurrence.character}`)
+            : `Change ${ctx.changeNumber}/${ctx.totalChanges} · ${safeFile}:${ctx.occurrence.line}:${ctx.occurrence.character}`,
+        useColor ? chalkInstance.cyan(hunkHeader) : hunkHeader,
+        ...splitDiffLines(ctx.occurrence.matched).map((line) => useColor ? chalkInstance.red(`-${escapeTerminalText(line)}`) : `-${escapeTerminalText(line)}`),
+        ...splitDiffLines(ctx.occurrence.replacement).map((line) => useColor
+            ? chalkInstance.green(`+${escapeTerminalText(line)}`)
+            : `+${escapeTerminalText(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");
+}
+export 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/command/interactive/types.d.ts

@@ -0,0 +1,13 @@
+import type { SpatchOccurrence, SpatchOptions } from "../../types.ts";
+export type InteractiveChoice = "yes" | "no" | "all" | "quit";
+export type InteractiveContext = {
+    file: string;
+    occurrence: SpatchOccurrence;
+    changeNumber: number;
+    totalChanges: number;
+};
+export type InteractiveDecider = (ctx: InteractiveContext) => Promise<InteractiveChoice>;
+export type RunInteractivePatchCommandOptions = Pick<SpatchOptions, "concurrency" | "cwd" | "encoding" | "logger" | "scope" | "verbose"> & {
+    noColor: boolean;
+    interactiveDecider?: InteractiveDecider;
+};

package/dist/command/interactive/validation.d.ts

@@ -0,0 +1,2 @@
+import type { SpatchOccurrence } from "../../types.ts";
+export declare function validateSelectedOccurrences(file: string, source: string, occurrences: readonly SpatchOccurrence[]): void;

package/dist/command/interactive/validation.js

@@ -0,0 +1,19 @@
+export function validateSelectedOccurrences(file, source, occurrences) {
+    const sorted = [...occurrences].sort((left, right) => left.start - right.start);
+    let cursor = 0;
+    for (const occurrence of sorted) {
+        if (occurrence.start < 0 ||
+            occurrence.end < occurrence.start ||
+            occurrence.end > source.length) {
+            throw new Error(`File changed during interactive patch selection: ${file}. Re-run spatch interactive to refresh match positions.`);
+        }
+        if (occurrence.start < cursor) {
+            throw new Error(`Invalid overlapping interactive occurrences for ${file}. Re-run spatch interactive.`);
+        }
+        const currentMatched = source.slice(occurrence.start, occurrence.end);
+        if (currentMatched !== occurrence.matched) {
+            throw new Error(`File changed during interactive patch selection: ${file}. Re-run spatch interactive to refresh match positions.`);
+        }
+        cursor = occurrence.end;
+    }
+}

package/dist/command/interactive.d.ts

@@ -0,0 +1 @@
+export { runInteractivePatchCommand } from "./interactive/run.ts";

package/dist/command/interactive.js

@@ -0,0 +1 @@
+export { runInteractivePatchCommand } from "./interactive/run.js";

package/dist/command/output.d.ts

@@ -0,0 +1,11 @@
+import { type ChalkInstance } from "chalk";
+import type { SpatchResult } from "../types.ts";
+export type FormatPatchOutputOptions = {
+    color?: boolean;
+    chalkInstance?: ChalkInstance;
+};
+export declare function formatPatchOutput(result: SpatchResult, options?: FormatPatchOutputOptions): string;
+export declare function buildChalk(options: FormatPatchOutputOptions): ChalkInstance;
+export declare function splitDiffLines(text: string): string[];
+export declare function countLines(text: string): number;
+export declare function escapeTerminalText(text: string): string;

package/dist/command/output.js

@@ -0,0 +1,82 @@
+import chalk, { Chalk } from "chalk";
+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 safeFile = escapeTerminalText(file.file);
+        const headerPrefix = useColor ? chalkInstance.bold : (value) => value;
+        lines.push(headerPrefix(`diff --git a/${safeFile} b/${safeFile}`));
+        lines.push(useColor ? chalkInstance.gray(`--- a/${safeFile}`) : `--- a/${safeFile}`);
+        lines.push(useColor ? chalkInstance.gray(`+++ b/${safeFile}`) : `+++ b/${safeFile}`);
+        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 = `-${escapeTerminalText(oldLine)}`;
+                lines.push(useColor ? chalkInstance.red(line) : line);
+            }
+            for (const newLine of splitDiffLines(occurrence.replacement)) {
+                const line = `+${escapeTerminalText(newLine)}`;
+                lines.push(useColor ? chalkInstance.green(line) : line);
+            }
+        }
+    }
+    if (changedFiles.length === 0) {
+        lines.push(useColor ? chalkInstance.gray("No changes.") : "No changes.");
+    }
+    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");
+}
+export 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 });
+}
+export function splitDiffLines(text) {
+    const normalized = text.replaceAll("\r\n", "\n");
+    if (normalized.length === 0) {
+        return [];
+    }
+    if (normalized.endsWith("\n")) {
+        return normalized.slice(0, -1).split("\n");
+    }
+    return normalized.split("\n");
+}
+export function countLines(text) {
+    return splitDiffLines(text).length;
+}
+export function escapeTerminalText(text) {
+    let output = "";
+    for (const char of text) {
+        const code = char.charCodeAt(0);
+        if (code === 0x1b || code < 0x20 || code === 0x7f) {
+            output += `\\x${code.toString(16).padStart(2, "0")}`;
+            continue;
+        }
+        output += char;
+    }
+    return output;
+}
+function pluralize(word, count) {
+    return count === 1 ? word : `${word}s`;
+}

package/dist/command.d.ts

@@ -1,29 +1,31 @@
-import { type ChalkInstance } from "chalk";
-import type { SpatchOccurrence, SpatchResult } from "./types.ts";
-export type PatchCommandFlags = {
-    "dry-run"?: boolean;
-    interactive?: boolean;
-    json?: boolean;
-    "no-color"?: boolean;
-    cwd?: string;
-    concurrency?: number;
-    verbose?: number;
+import { type PatchCommandFlags } from "./command/flags.ts";
+import type { InteractiveDecider } from "./command/interactive/types.ts";
+import type { SpatchResult } from "./types.ts";
+type RunPatchCommandOptions = {
+    interactiveDecider?: InteractiveDecider;
+    /**
+     * Text encoding used for reading/writing scoped source files.
+     * Defaults to "utf8".
+     */
+    encoding?: BufferEncoding;
+    /**
+     * Optional logger override. Defaults to stderr when --verbose is enabled.
+     */
+    logger?: (line: string) => void;
+    /**
+     * Used for testing / embedding. If omitted and patch input is "-", stdin will
+     * be read from the current process.
+     */
+    readStdin?: () => Promise<string>;
+    /**
+     * Optional stream source for stdin patch input. Ignored when `readStdin` is
+     * provided. Defaults to process stdin.
+     */
+    stdinStream?: ReadableTextStream;
 };
-type InteractiveChoice = "yes" | "no" | "all" | "quit";
-export type InteractiveContext = {
-    file: string;
-    occurrence: SpatchOccurrence;
-    changeNumber: number;
-    totalChanges: number;
-};
-export type RunPatchCommandOptions = {
-    interactiveDecider?: (ctx: InteractiveContext) => Promise<InteractiveChoice>;
+type ReadableTextStream = AsyncIterable<unknown> & {
+    setEncoding?(encoding: BufferEncoding): void;
 };
 export declare function runPatchCommand(patchInput: string, scope: string | undefined, flags: PatchCommandFlags, options?: RunPatchCommandOptions): Promise<SpatchResult>;
-type FormatPatchOutputOptions = {
-    color?: boolean;
-    chalkInstance?: ChalkInstance;
-};
-export declare function formatPatchOutput(result: SpatchResult, options?: FormatPatchOutputOptions): string;
 export declare const patchCommand: import("@stricli/core").Command<import("@stricli/core").CommandContext>;
 export {};