@beignet/cli 0.0.40 → 0.0.42

package/src/doctor-fixes.ts

@@ -0,0 +1,252 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { createTwoFilesPatch } from "diff";
+import { type DoctorFixOperationId, doctorFixOperationIds } from "./choices.js";
+
+export type { DoctorFixOperationId } from "./choices.js";
+export { doctorFixOperationIds } from "./choices.js";
+
+/** Automatic doctor fix that was applied. */
+export type InspectFix = {
+  code: string;
+  message: string;
+  file: string;
+};
+
+/** Exact file mutation proposed by a doctor fix operation. */
+export type DoctorFixFileChange = {
+  file: string;
+  kind: "create" | "update";
+  beforeHash: string | null;
+  afterHash: string;
+  patch: string;
+};
+
+/** Selectable low-risk repair and every file change it requires. */
+export type DoctorFixOperation = {
+  id: DoctorFixOperationId;
+  fixes: InspectFix[];
+  changes: DoctorFixFileChange[];
+};
+
+/** Deterministic, read-only repair plan for the current app state. */
+export type DoctorFixPlan = {
+  schemaVersion: 1;
+  targetDir: string;
+  strict: boolean;
+  planId: string;
+  operations: DoctorFixOperation[];
+};
+
+/** Result of applying all or part of a guarded doctor fix plan. */
+export type DoctorFixApplyResult = {
+  schemaVersion: 1;
+  targetDir: string;
+  planId: string;
+  operationIds: DoctorFixOperationId[];
+  fixes: InspectFix[];
+};
+
+export type PlannedDoctorFixFileChange = DoctorFixFileChange & {
+  before: string | undefined;
+  after: string;
+};
+
+export type PlannedDoctorFixOperation = Omit<DoctorFixOperation, "changes"> & {
+  changes: PlannedDoctorFixFileChange[];
+};
+
+export type PlannedDoctorFixPlan = Omit<DoctorFixPlan, "operations"> & {
+  operations: PlannedDoctorFixOperation[];
+};
+
+export function planDoctorFixFileChange(options: {
+  file: string;
+  before?: string;
+  after: string;
+}): PlannedDoctorFixFileChange {
+  const oldName =
+    options.before === undefined ? "/dev/null" : `a/${options.file}`;
+  const newName = `b/${options.file}`;
+  return {
+    file: options.file,
+    kind: options.before === undefined ? "create" : "update",
+    beforeHash:
+      options.before === undefined ? null : contentHash(options.before),
+    afterHash: contentHash(options.after),
+    patch: createTwoFilesPatch(
+      oldName,
+      newName,
+      options.before ?? "",
+      options.after,
+      "",
+      "",
+      { context: 3 },
+    ),
+    before: options.before,
+    after: options.after,
+  };
+}
+
+export function createDoctorFixPlan(options: {
+  targetDir: string;
+  strict: boolean;
+  operations: PlannedDoctorFixOperation[];
+}): PlannedDoctorFixPlan {
+  const operationOrder = new Map(
+    doctorFixOperationIds.map((id, index) => [id, index]),
+  );
+  const operations = [...options.operations].sort(
+    (left, right) =>
+      (operationOrder.get(left.id) ?? Number.MAX_SAFE_INTEGER) -
+      (operationOrder.get(right.id) ?? Number.MAX_SAFE_INTEGER),
+  );
+  const fingerprint = {
+    targetDir: path.resolve(options.targetDir),
+    operations: operations.map((operation) => ({
+      id: operation.id,
+      changes: operation.changes.map((change) => ({
+        file: change.file,
+        beforeHash: change.beforeHash,
+        afterHash: change.afterHash,
+      })),
+    })),
+  };
+
+  return {
+    schemaVersion: 1,
+    targetDir: path.resolve(options.targetDir),
+    strict: options.strict,
+    planId: contentHash(JSON.stringify(fingerprint)),
+    operations,
+  };
+}
+
+export function publicDoctorFixPlan(plan: PlannedDoctorFixPlan): DoctorFixPlan {
+  return {
+    ...plan,
+    operations: plan.operations.map((operation) => ({
+      id: operation.id,
+      fixes: operation.fixes,
+      changes: operation.changes.map(
+        ({ before: _before, after: _after, ...change }) => change,
+      ),
+    })),
+  };
+}
+
+export async function applyPlannedDoctorFixes(
+  plan: PlannedDoctorFixPlan,
+  fixIds?: readonly DoctorFixOperationId[],
+  hooks: {
+    beforeWrite?: (
+      change: PlannedDoctorFixFileChange,
+      index: number,
+    ) => void | Promise<void>;
+  } = {},
+): Promise<DoctorFixApplyResult> {
+  const requested = fixIds ? new Set(fixIds) : undefined;
+  const operations = requested
+    ? plan.operations.filter((operation) => requested.has(operation.id))
+    : plan.operations;
+
+  if (requested) {
+    const available = new Set(plan.operations.map((operation) => operation.id));
+    const missing = [...requested].filter((id) => !available.has(id));
+    if (missing.length > 0) {
+      throw new Error(
+        `Doctor fix operations are not available in this plan: ${missing.join(", ")}. Run beignet doctor --fix --dry-run again.`,
+      );
+    }
+  }
+
+  const changes = operations.flatMap((operation) => operation.changes);
+  const duplicateFiles = duplicateValues(changes.map((change) => change.file));
+  if (duplicateFiles.length > 0) {
+    throw new Error(
+      `Doctor fix operations overlap on ${duplicateFiles.join(", ")}; no files were changed.`,
+    );
+  }
+
+  for (const change of changes) {
+    const current = await readOptionalFile(
+      path.join(plan.targetDir, change.file),
+    );
+    const currentHash = current === undefined ? null : contentHash(current);
+    if (currentHash !== change.beforeHash) {
+      throw new Error(
+        `Doctor fix plan is stale because ${change.file} changed. No files were changed; run beignet doctor --fix --dry-run again.`,
+      );
+    }
+  }
+
+  const attempted: PlannedDoctorFixFileChange[] = [];
+  try {
+    for (const [index, change] of changes.entries()) {
+      attempted.push(change);
+      await hooks.beforeWrite?.(change, index);
+      const destination = path.join(plan.targetDir, change.file);
+      await mkdir(path.dirname(destination), { recursive: true });
+      await writeFile(destination, change.after);
+    }
+  } catch (error) {
+    const rollbackErrors: string[] = [];
+    for (const change of attempted.reverse()) {
+      const destination = path.join(plan.targetDir, change.file);
+      try {
+        if (change.before === undefined) {
+          await rm(destination, { force: true });
+        } else {
+          await mkdir(path.dirname(destination), { recursive: true });
+          await writeFile(destination, change.before);
+        }
+      } catch (rollbackError) {
+        rollbackErrors.push(
+          rollbackError instanceof Error
+            ? rollbackError.message
+            : String(rollbackError),
+        );
+      }
+    }
+
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      rollbackErrors.length === 0
+        ? `Doctor fix application failed and was rolled back: ${message}`
+        : `Doctor fix application failed: ${message}. Rollback also failed: ${rollbackErrors.join("; ")}`,
+      { cause: error },
+    );
+  }
+
+  return {
+    schemaVersion: 1,
+    targetDir: plan.targetDir,
+    planId: plan.planId,
+    operationIds: operations.map((operation) => operation.id),
+    fixes: operations.flatMap((operation) => operation.fixes),
+  };
+}
+
+function contentHash(value: string): string {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+async function readOptionalFile(file: string): Promise<string | undefined> {
+  try {
+    return await readFile(file, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+    throw error;
+  }
+}
+
+function duplicateValues(values: readonly string[]): string[] {
+  const seen = new Set<string>();
+  const duplicates = new Set<string>();
+  for (const value of values) {
+    if (seen.has(value)) duplicates.add(value);
+    seen.add(value);
+  }
+  return [...duplicates].sort();
+}