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

package/dist/apply-patch/jsdiff.js

@@ -0,0 +1,219 @@
+import { Worker } from "node:worker_threads";
+import { isRecord } from "@hheei/pi-ext-core";
+import { compileV4aUpdateToUnifiedDiff } from "./parser.js";
+const INTERNAL_PATH = "__apply_patch_target__";
+const WORKER_URL = new URL(import.meta.url.endsWith(".ts") ? "./jsdiff-worker.ts" : "./jsdiff-worker.js", import.meta.url);
+function isFiniteInteger(value) {
+    return typeof value === "number" && Number.isInteger(value);
+}
+function parseRejected(value) {
+    if (!isRecord(value) || !isFiniteInteger(value.hunkIndex) || value.hunkIndex < 1)
+        return undefined;
+    if (value.kind === "context_not_found") {
+        const hint = typeof value.hint === "string" ? value.hint : undefined;
+        return {
+            kind: "context_not_found",
+            hunkIndex: value.hunkIndex,
+            ...(hint !== undefined ? { hint } : {}),
+        };
+    }
+    if (value.kind !== "ambiguous_exact" || !Array.isArray(value.candidateStartLines))
+        return undefined;
+    const candidateStartLines = [];
+    for (const line of value.candidateStartLines) {
+        if (!isFiniteInteger(line) || line < 1)
+            return undefined;
+        candidateStartLines.push(line);
+    }
+    return {
+        kind: "ambiguous_exact",
+        hunkIndex: value.hunkIndex,
+        candidateStartLines: Object.freeze(candidateStartLines),
+    };
+}
+function parseStringList(value) {
+    if (!Array.isArray(value) || value.some((line) => typeof line !== "string"))
+        return undefined;
+    return Object.freeze([...value]);
+}
+function parsePrepared(value, expectedHunks, snapshotPath) {
+    if (!isRecord(value) ||
+        !(value.after instanceof Uint8Array) ||
+        value.after.byteLength > 32 * 1024 * 1024)
+        return undefined;
+    if (value.mode !== undefined && value.mode !== "exact" && value.mode !== "fuzzy")
+        return undefined;
+    if (!isFiniteInteger(value.addedLines) ||
+        !isFiniteInteger(value.removedLines) ||
+        value.addedLines < 0 ||
+        value.removedLines < 0 ||
+        !Array.isArray(value.outcomes) ||
+        !Array.isArray(value.rejected) ||
+        !Array.isArray(value.snapshots))
+        return undefined;
+    const seen = new Set();
+    const outcomes = [];
+    for (const outcome of value.outcomes) {
+        if (!isRecord(outcome) ||
+            outcome.kind !== "applied" ||
+            !isFiniteInteger(outcome.hunkIndex) ||
+            !isFiniteInteger(outcome.startLine) ||
+            !isFiniteInteger(outcome.length) ||
+            outcome.hunkIndex < 1 ||
+            outcome.hunkIndex > expectedHunks ||
+            outcome.startLine < 1 ||
+            outcome.length < 0 ||
+            (outcome.match !== "exact" && outcome.match !== "fuzzy") ||
+            seen.has(outcome.hunkIndex))
+            return undefined;
+        seen.add(outcome.hunkIndex);
+        outcomes.push({
+            kind: "applied",
+            hunkIndex: outcome.hunkIndex,
+            startLine: outcome.startLine,
+            length: outcome.length,
+            match: outcome.match,
+        });
+    }
+    const rejected = [];
+    for (const item of value.rejected) {
+        const parsed = parseRejected(item);
+        if (parsed === undefined || parsed.hunkIndex > expectedHunks || seen.has(parsed.hunkIndex))
+            return undefined;
+        seen.add(parsed.hunkIndex);
+        rejected.push(parsed);
+    }
+    if (seen.size !== expectedHunks)
+        return undefined;
+    const snapshots = [];
+    for (const snapshot of value.snapshots) {
+        if (!isRecord(snapshot) || snapshot.path !== snapshotPath)
+            return undefined;
+        if (!isFiniteInteger(snapshot.hunkIndex) ||
+            !isFiniteInteger(snapshot.startLine) ||
+            !isFiniteInteger(snapshot.afterStartLine) ||
+            snapshot.hunkIndex < 1 ||
+            snapshot.hunkIndex > expectedHunks ||
+            snapshot.startLine < 1 ||
+            snapshot.afterStartLine < 1)
+            return undefined;
+        const before = parseStringList(snapshot.before);
+        const after = parseStringList(snapshot.after);
+        if (before === undefined || after === undefined)
+            return undefined;
+        snapshots.push({
+            path: snapshot.path,
+            hunkIndex: snapshot.hunkIndex,
+            startLine: snapshot.startLine,
+            afterStartLine: snapshot.afterStartLine,
+            before,
+            after,
+        });
+    }
+    return {
+        after: value.after,
+        mode: value.mode,
+        addedLines: value.addedLines,
+        removedLines: value.removedLines,
+        outcomes: Object.freeze(outcomes),
+        rejected: Object.freeze(rejected),
+        snapshots: Object.freeze(snapshots),
+    };
+}
+export async function runJsDiffUpdate(options) {
+    options.signal?.throwIfAborted();
+    if (options.operation.hunks.length === 0)
+        return {
+            after: options.before,
+            mode: undefined,
+            addedLines: 0,
+            removedLines: 0,
+            outcomes: Object.freeze([]),
+            rejected: Object.freeze([]),
+            snapshots: Object.freeze([]),
+        };
+    const workerData = {
+        before: options.before,
+        hunks: options.operation.hunks.map((hunk) => ({
+            unifiedDiff: compileV4aUpdateToUnifiedDiff({
+                kind: "update",
+                path: INTERNAL_PATH,
+                hunks: [hunk],
+            }),
+            hunk,
+        })),
+        fuzzFactor: options.fuzzFactor,
+        snapshotPath: options.operation.moveTo ?? options.operation.path,
+    };
+    options.signal?.throwIfAborted();
+    const worker = new Worker(WORKER_URL, { workerData });
+    let settled = false;
+    let abortHandler;
+    const cleanup = () => {
+        if (abortHandler !== undefined)
+            options.signal?.removeEventListener("abort", abortHandler);
+        worker.removeAllListeners();
+    };
+    try {
+        return await new Promise((resolve, reject) => {
+            let message;
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(error);
+            };
+            const succeed = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(value);
+            };
+            abortHandler = () => {
+                void worker.terminate().then(() => fail(options.signal?.reason ?? new Error("aborted")), (error) => fail(options.signal?.reason ?? error));
+            };
+            worker.once("message", (value) => {
+                message = value;
+            });
+            worker.once("error", (error) => fail(error));
+            worker.once("exit", (code) => {
+                if (settled)
+                    return;
+                if (options.signal?.aborted) {
+                    fail(options.signal.reason ?? new Error("aborted"));
+                    return;
+                }
+                if (code !== 0 && code !== null) {
+                    fail(new Error(`jsdiff worker exited with code ${code}`));
+                    return;
+                }
+                if (!isRecord(message) || (message.kind !== "result" && message.kind !== "error")) {
+                    fail(new Error("jsdiff worker returned an invalid result"));
+                    return;
+                }
+                if (message.kind === "error") {
+                    fail(new Error(typeof message.message === "string" ? message.message : "jsdiff worker failed"));
+                    return;
+                }
+                const prepared = parsePrepared(message.value, options.operation.hunks.length, options.operation.moveTo ?? options.operation.path);
+                if (prepared === undefined) {
+                    fail(new Error("jsdiff worker returned an invalid result"));
+                    return;
+                }
+                succeed(prepared);
+            });
+            options.signal?.addEventListener("abort", abortHandler, { once: true });
+            if (options.signal?.aborted)
+                abortHandler();
+        });
+    }
+    finally {
+        if (!settled) {
+            settled = true;
+            cleanup();
+            await worker.terminate();
+        }
+    }
+}

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

@@ -0,0 +1,84 @@
+export type PatchHunkOutcome = {
+    readonly kind: "applied";
+    readonly hunkIndex: number;
+    readonly startLine: number;
+    readonly length: number;
+    readonly match: "exact" | "fuzzy";
+} | {
+    readonly kind: "context_not_found";
+    readonly hunkIndex: number;
+    readonly hint?: string;
+} | {
+    readonly kind: "ambiguous_exact";
+    readonly hunkIndex: number;
+    readonly candidateStartLines: readonly number[];
+};
+export type AppliedPatchHunk = Extract<PatchHunkOutcome, {
+    readonly kind: "applied";
+}>;
+export type RejectedPatchHunk = Exclude<PatchHunkOutcome, {
+    readonly kind: "applied";
+}>;
+export interface ApplyPatchHunkSnapshot {
+    readonly path: string;
+    readonly hunkIndex: number;
+    readonly startLine: number;
+    readonly afterStartLine: number;
+    readonly before: readonly string[];
+    readonly after: readonly string[];
+}
+export interface PreparedPatchUpdate {
+    readonly after: Uint8Array;
+    readonly mode: "exact" | "fuzzy" | undefined;
+    readonly addedLines: number;
+    readonly removedLines: number;
+    readonly outcomes: readonly AppliedPatchHunk[];
+    readonly rejected: readonly RejectedPatchHunk[];
+    readonly snapshots: readonly ApplyPatchHunkSnapshot[];
+}
+export interface ApplyPatchAppliedOperation {
+    readonly operationIndex: number;
+    readonly kind: "add" | "delete" | "update";
+    readonly paths: readonly string[];
+    readonly outcomes: readonly AppliedPatchHunk[];
+    readonly snapshots: readonly ApplyPatchHunkSnapshot[];
+}
+export interface ApplyPatchRejection {
+    readonly operationIndices: readonly number[];
+    readonly paths: readonly string[];
+    readonly error: string;
+    readonly diagnostics: readonly RejectedPatchHunk[];
+}
+export type ApplyPatchProgressStage = "parsed" | "publishing" | "done";
+export type ApplyPatchOperationStatus = "pending" | "applied" | "partial" | "fuzzy" | "rejected" | "unconfirmed" | "not_applied";
+export type ApplyPatchOperationProgress = {
+    readonly operationIndex: number;
+    readonly kind: "add" | "delete" | "update";
+    readonly path: string;
+    readonly addedLines: number;
+    readonly removedLines: number;
+    readonly status: ApplyPatchOperationStatus;
+    readonly appliedHunks?: number;
+    readonly totalHunks?: number;
+    readonly partialReason?: string;
+};
+export interface ApplyPatchProgress {
+    readonly stage: ApplyPatchProgressStage;
+    readonly files: number;
+    readonly addedLines: number;
+    readonly removedLines: number;
+    readonly operations: readonly ApplyPatchOperationProgress[];
+}
+export interface ApplyPatchInWorkspaceResult {
+    readonly changedPaths: readonly string[];
+    readonly addedLines: number;
+    readonly removedLines: number;
+    readonly operations: readonly ApplyPatchOperationProgress[];
+    readonly operationCount: number;
+    readonly exactUpdateCount: number;
+    readonly fuzzyUpdateCount: number;
+    readonly applied: readonly ApplyPatchAppliedOperation[];
+    readonly rejected: readonly ApplyPatchRejection[];
+    readonly unconfirmed: readonly ApplyPatchRejection[];
+    readonly notApplied: readonly ApplyPatchRejection[];
+}

package/dist/apply-patch/outcome.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,85 @@
+export type V4aPatchOperation = V4aAddOperation | V4aDeleteOperation | V4aUpdateOperation;
+export interface V4aAddOperation {
+    readonly kind: "add";
+    readonly path: string;
+    readonly content: string;
+}
+export interface V4aDeleteOperation {
+    readonly kind: "delete";
+    readonly path: string;
+}
+export interface V4aUpdateOperation {
+    readonly kind: "update";
+    readonly path: string;
+    readonly moveTo?: string;
+    readonly hunks: readonly V4aUpdateHunk[];
+}
+export interface V4aUpdateHunk {
+    readonly anchor?: string;
+    readonly anchors?: readonly string[];
+    readonly endOfFile?: true;
+    readonly lines: readonly V4aUpdateLine[];
+}
+export type V4aUpdateLine = V4aContextLine | V4aAddedLine | V4aRemovedLine;
+export interface V4aContextLine {
+    readonly kind: "context";
+    readonly text: string;
+    readonly noNewline?: true;
+}
+export interface V4aAddedLine {
+    readonly kind: "add";
+    readonly text: string;
+    readonly noNewline?: true;
+}
+export interface V4aRemovedLine {
+    readonly kind: "remove";
+    readonly text: string;
+    readonly noNewline?: true;
+}
+export interface V4aPatch {
+    readonly operations: readonly V4aPatchOperation[];
+}
+export interface V4aPatchConflict {
+    readonly path: string;
+    readonly operationIndices: readonly number[];
+    readonly message: string;
+}
+export declare const MAX_V4A_PATCH_BYTES = 1048576;
+export declare const MAX_V4A_OPERATIONS = 128;
+export declare const MAX_V4A_HUNKS_PER_UPDATE = 128;
+export declare const MAX_V4A_HUNK_LINES = 4096;
+export declare const MAX_V4A_PATH_BYTES = 4096;
+export declare const MAX_V4A_PATH_SEGMENT_BYTES = 255;
+export interface V4aPreviewOperation {
+    readonly kind: "add" | "delete" | "update";
+    readonly path: string;
+    readonly addedLines: number;
+    readonly removedLines: number;
+}
+type MutablePreviewOperation = {
+    kind: V4aPreviewOperation["kind"];
+    path: string;
+    addedLines: number;
+    removedLines: number;
+};
+export interface V4aPreviewCursor {
+    consumed: string;
+    bytes: number;
+    operations: MutablePreviewOperation[];
+    stopped: boolean;
+}
+export declare function createV4aPreviewCursor(): V4aPreviewCursor;
+export declare function previewV4aPatchPrefix(input: string, argsComplete?: boolean, cursor?: V4aPreviewCursor): readonly V4aPreviewOperation[];
+/** Counts unique completed operation paths. Ignores payload lines and partial last lines. */
+export declare function previewV4aPatchFileCount(input: string, cursor?: V4aPreviewCursor): number;
+export declare function parseV4aPatch(input: string): V4aPatch;
+/**
+ * Parses a V4A patch one complete operation at a time. Callers may present
+ * parsed operations before workspace validation or mutation begins.
+ */
+export declare function parseV4aPatchProgressively(input: string, onOperation: (operation: V4aPatchOperation, index: number) => void | Promise<void>): Promise<V4aPatch>;
+export declare function operationTouchedPaths(operation: V4aPatchOperation): readonly string[];
+/** Finds operation graph conflicts without reading or mutating the workspace. */
+export declare function findV4aPatchConflicts(patch: V4aPatch): readonly V4aPatchConflict[];
+export declare function compileV4aUpdateToUnifiedDiff(operation: V4aUpdateOperation): string;
+export {};