@hheei/pi-apply-patch 0.0.0-stage → 0.1.0

package/dist/apply-patch/fs.js

@@ -0,0 +1,186 @@
+import { randomUUID } from "node:crypto";
+import { link, lstat, mkdir, readdir, readFile, realpath, rename, stat, unlink, writeFile, } from "node:fs/promises";
+import { dirname, isAbsolute, win32 } from "node:path";
+import { resolvePatchPath } from "./paths.js";
+export const APPLY_PATCH_MAX_FILE_SIZE = 32 * 1024 * 1024;
+export const SFTP_SMALL_BYTES = 1_048_576;
+export const SFTP_SMALL_TIMEOUT_MS = 30_000;
+export const SFTP_LARGE_TIMEOUT_MS = 60_000;
+const TEMP_RE = /^\..+\.agentpatch-[0-9a-f-]{36}\.tmp$/iu;
+export class FsTransportError extends Error {
+    phase;
+    timedOut;
+    constructor(phase, timedOut, message) {
+        super(message);
+        this.name = "FsTransportError";
+        this.phase = phase;
+        this.timedOut = timedOut;
+    }
+}
+export function sftpTimeoutMs(bytes) {
+    return bytes <= SFTP_SMALL_BYTES ? SFTP_SMALL_TIMEOUT_MS : SFTP_LARGE_TIMEOUT_MS;
+}
+export function agentPatchTempName(base) {
+    return `.${base}.agentpatch-${randomUUID()}.tmp`;
+}
+export function isAgentPatchTemp(name) {
+    return TEMP_RE.test(name);
+}
+export function fileTooLarge(size, path) {
+    return new Error(`file_too_large (${size} > ${APPLY_PATCH_MAX_FILE_SIZE}) at ${path}; use another tool suitable for large-file edits.`);
+}
+/** Installs fully prepared bytes through one sibling temporary file. */
+export async function publishPreparedFile(fs, path, data, mode, replaceExisting, signal, beforePublish) {
+    const slash = path.lastIndexOf("/");
+    const directory = slash < 0 ? "." : path.slice(0, slash);
+    if (directory !== ".")
+        await fs.mkdirp(directory, signal);
+    const base = slash < 0 ? path : path.slice(slash + 1);
+    const temp = `${directory === "." ? "" : `${directory}/`}${agentPatchTempName(base)}`;
+    try {
+        await fs.writeAtomic(temp, data, mode, signal);
+        await beforePublish?.();
+        if (replaceExisting)
+            await fs.replace(temp, path, signal);
+        else
+            await fs.renameNew(temp, path, signal);
+    }
+    catch (error) {
+        if (!(error instanceof FsTransportError) || error.phase === "write")
+            await fs.unlink(temp).catch(() => undefined);
+        throw error;
+    }
+}
+function isMissing(error) {
+    return error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
+}
+function localMeta(info, kindOverride) {
+    const kind = kindOverride ??
+        (info.isSymbolicLink()
+            ? "symlink"
+            : info.isFile()
+                ? "file"
+                : info.isDirectory()
+                    ? "directory"
+                    : "other");
+    return {
+        kind,
+        size: info.size,
+        mode: info.mode & 0o7777,
+    };
+}
+export function createLocalPatchFs(workspaceRoot) {
+    const abs = (path) => isAbsolute(path) || win32.isAbsolute(path) ? path : resolvePatchPath(workspaceRoot, path);
+    return {
+        scope: workspaceRoot,
+        async lstat(path, signal) {
+            signal?.throwIfAborted();
+            try {
+                return localMeta(await lstat(abs(path)));
+            }
+            catch (error) {
+                if (isMissing(error))
+                    return { kind: "missing", size: 0 };
+                throw error;
+            }
+        },
+        async statFollow(path, signal) {
+            signal?.throwIfAborted();
+            try {
+                const info = await stat(abs(path));
+                return localMeta(info, info.isFile() ? "file" : info.isDirectory() ? "directory" : "other");
+            }
+            catch (error) {
+                if (isMissing(error))
+                    return { kind: "missing", size: 0 };
+                throw error;
+            }
+        },
+        async followLeaf(path, signal) {
+            signal?.throwIfAborted();
+            const current = abs(path);
+            try {
+                const info = await lstat(current);
+                if (!info.isSymbolicLink())
+                    return path;
+                return await realpath(current);
+            }
+            catch (error) {
+                if (isMissing(error))
+                    return path;
+                throw error;
+            }
+        },
+        async readFollow(path, signal) {
+            return await readFile(abs(path), signal === undefined ? undefined : { signal });
+        },
+        async mkdirp(path, signal) {
+            signal?.throwIfAborted();
+            await mkdir(abs(path), { recursive: true });
+        },
+        async writeAtomic(path, data, mode, signal) {
+            signal?.throwIfAborted();
+            const target = abs(path);
+            await mkdir(dirname(target), { recursive: true });
+            await writeFile(target, data, {
+                ...(signal === undefined ? {} : { signal }),
+                ...(mode === undefined ? {} : { mode }),
+            });
+        },
+        async renameNew(from, to, signal) {
+            signal?.throwIfAborted();
+            await link(abs(from), abs(to));
+            await unlink(abs(from)).catch(() => undefined);
+        },
+        async replace(from, to, signal) {
+            if (signal?.aborted)
+                throw new FsTransportError("replace", false, "cancelled before replace");
+            try {
+                await rename(abs(from), abs(to));
+            }
+            catch (error) {
+                if (signal?.aborted)
+                    throw new FsTransportError("replace", false, "cancelled during replace");
+                throw error;
+            }
+        },
+        async unlink(path, signal) {
+            if (signal?.aborted)
+                throw new FsTransportError("remove", false, "cancelled before remove");
+            try {
+                await unlink(abs(path));
+            }
+            catch (error) {
+                if (signal?.aborted)
+                    throw new FsTransportError("remove", false, "cancelled during remove");
+                throw error;
+            }
+        },
+        async list(path) {
+            try {
+                return await readdir(path === "" || path === "." ? workspaceRoot : abs(path));
+            }
+            catch (error) {
+                if (isMissing(error))
+                    return [];
+                throw error;
+            }
+        },
+    };
+}
+export async function gcAgentPatchTemps(fs, directories, signal) {
+    const seen = new Set();
+    for (const directory of directories) {
+        const key = directory === "" ? "." : directory;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const names = await fs.list(key, signal);
+        for (const name of names) {
+            if (!isAgentPatchTemp(name))
+                continue;
+            const path = key === "." ? name : `${key}/${name}`;
+            await fs.unlink(path, signal).catch(() => undefined);
+        }
+    }
+}

package/dist/apply-patch/glyph.d.ts

@@ -0,0 +1,8 @@
+import type { ApplyPatchOperationStatus } from "./outcome.js";
+/**
+ * How one mutation outcome is drawn, in the Nerd Font vocabulary the framed tool status and the
+ * todo rows already use. `apply_patch` operation rows and the remote `edit`/`write` failure lines
+ * share it, so one outcome never draws two different symbols across the tools.
+ */
+export declare const MUTATION_GLYPH: Record<ApplyPatchOperationStatus, string>;
+export declare const MUTATION_TONE: Record<ApplyPatchOperationStatus, "success" | "warning" | "dim" | "error">;

package/dist/apply-patch/glyph.js

@@ -0,0 +1,23 @@
+/**
+ * How one mutation outcome is drawn, in the Nerd Font vocabulary the framed tool status and the
+ * todo rows already use. `apply_patch` operation rows and the remote `edit`/`write` failure lines
+ * share it, so one outcome never draws two different symbols across the tools.
+ */
+export const MUTATION_GLYPH = {
+    pending: "󰄰",
+    applied: "󰄴",
+    partial: "󰪠",
+    fuzzy: "󰾞",
+    unconfirmed: "󰘥",
+    not_applied: "󰍷",
+    rejected: "󰅚",
+};
+export const MUTATION_TONE = {
+    pending: "dim",
+    applied: "success",
+    partial: "warning",
+    fuzzy: "warning",
+    unconfirmed: "warning",
+    not_applied: "dim",
+    rejected: "error",
+};

package/dist/apply-patch/index.d.ts

@@ -0,0 +1,6 @@
+export { type ApplyPatchInWorkspaceOptions, applyPatchInWorkspace, } from "./executor.js";
+export { APPLY_PATCH_MAX_FILE_SIZE, createLocalPatchFs, FsTransportError, fileTooLarge, gcAgentPatchTemps, type PatchFs, publishPreparedFile, } from "./fs.js";
+export { MUTATION_GLYPH, MUTATION_TONE } from "./glyph.js";
+export type { ApplyPatchAppliedOperation, ApplyPatchHunkSnapshot, ApplyPatchInWorkspaceResult, ApplyPatchOperationProgress, ApplyPatchProgress, ApplyPatchRejection, PatchHunkOutcome, PreparedPatchUpdate, } from "./outcome.js";
+export { compileV4aUpdateToUnifiedDiff, createV4aPreviewCursor, findV4aPatchConflicts, MAX_V4A_HUNK_LINES, MAX_V4A_HUNKS_PER_UPDATE, MAX_V4A_OPERATIONS, MAX_V4A_PATCH_BYTES, MAX_V4A_PATH_BYTES, MAX_V4A_PATH_SEGMENT_BYTES, operationTouchedPaths, parseV4aPatch, parseV4aPatchProgressively, previewV4aPatchFileCount, previewV4aPatchPrefix, type V4aAddedLine, type V4aAddOperation, type V4aContextLine, type V4aDeleteOperation, type V4aPatch, type V4aPatchConflict, type V4aPatchOperation, type V4aPreviewCursor, type V4aPreviewOperation, type V4aRemovedLine, type V4aUpdateHunk, type V4aUpdateLine, type V4aUpdateOperation, } from "./parser.js";
+export { type ApplyPatchPolicy, DEFAULT_APPLY_PATCH_POLICY, type LoadApplyPatchPolicyOptions, loadApplyPatchPolicy, } from "./policy.js";

package/dist/apply-patch/index.js

@@ -0,0 +1,5 @@
+export { applyPatchInWorkspace, } from "./executor.js";
+export { APPLY_PATCH_MAX_FILE_SIZE, createLocalPatchFs, FsTransportError, fileTooLarge, gcAgentPatchTemps, publishPreparedFile, } from "./fs.js";
+export { MUTATION_GLYPH, MUTATION_TONE } from "./glyph.js";
+export { compileV4aUpdateToUnifiedDiff, createV4aPreviewCursor, findV4aPatchConflicts, MAX_V4A_HUNK_LINES, MAX_V4A_HUNKS_PER_UPDATE, MAX_V4A_OPERATIONS, MAX_V4A_PATCH_BYTES, MAX_V4A_PATH_BYTES, MAX_V4A_PATH_SEGMENT_BYTES, operationTouchedPaths, parseV4aPatch, parseV4aPatchProgressively, previewV4aPatchFileCount, previewV4aPatchPrefix, } from "./parser.js";
+export { DEFAULT_APPLY_PATCH_POLICY, loadApplyPatchPolicy, } from "./policy.js";

package/dist/apply-patch/jsdiff-matching.d.ts

@@ -0,0 +1,13 @@
+import type { PreparedPatchUpdate } from "./outcome.js";
+import type { V4aUpdateHunk } from "./parser.js";
+export interface JsDiffHunkInput {
+    readonly unifiedDiff: string;
+    readonly hunk: V4aUpdateHunk;
+}
+export interface JsDiffUpdateInput {
+    readonly before: Uint8Array;
+    readonly hunks: readonly JsDiffHunkInput[];
+    readonly fuzzFactor: number;
+    readonly snapshotPath: string;
+}
+export declare function prepareJsDiffUpdate(data: JsDiffUpdateInput): PreparedPatchUpdate;