dsh-hashline-edit 0.2.2 → 0.2.3

package/src/apply-patch/commit.ts

@@ -0,0 +1,190 @@
+/**
+ * apply_patch v4 — commit seam.
+ *
+ * Commits a `PatchPlan` as ONE correlated transaction through the existing hashline machinery:
+ *
+ * - pre-mirror every written member (durable pre-images),
+ * - one undo row per member carrying the shared transaction id,
+ * - the durable intent record,
+ * - deterministic member order (primary first), lifecycle actions included,
+ * - best-effort rollback of every member on failure,
+ * - the per-file store commit and the new-anchor served rows.
+ *
+ * This module is deliberately thin: it maps `PlannedFile` onto the engine's
+ * `ProcessedEditFile`/`commitTransaction` skeleton and never re-implements hashing, leasing,
+ * snapshots or undo storage.
+ *
+ * @module dsh-hashline-edit/apply-patch/commit
+ */
+import { SERVED_ROWS_CAP } from "../constants.js";
+import { DomainError } from "../domain-errors.js";
+import { genDiff } from "../edit-diff.js";
+import type { HashStore } from "../hash-store.js";
+import { commitTransaction } from "../mutation-engine/pipeline.js";
+import type { ProcessedEditFile, TransactionRecoveryReport } from "../mutation-engine/types.js";
+import { fmtServedRows, paginationHint } from "../served-session/serve-render.js";
+import { visLines } from "../utils.js";
+import { materializeMember, type MaterializedMember } from "./lifecycle.js";
+import type { ApplyPatchFailure, PatchProblem, PatchPlan, ServedFileBlock } from "./types.js";
+
+/** Options for {@link commitPlan}. */
+export interface CommitPlanOptions {
+  readonly cwd: string;
+  readonly sessionKey: string;
+  readonly signal?: AbortSignal;
+  readonly store?: HashStore;
+  /** POSIX access-mode bitmask; defaults to read+write. */
+  readonly accessMode?: number;
+  /** TEST-ONLY: fires before the first rename, while the pre-images/undo rows are durable. */
+  readonly onBeforeFirstWrite?: () => void | Promise<void>;
+  /** TEST-ONLY: fires between two member renames, after the earlier one is durable. */
+  readonly onBetweenWrites?: (committedAbsolutePath: string) => void | Promise<void>;
+  /** TEST-ONLY: fires after a move rename and before the destination rewrite (mid-member failure). */
+  readonly onAfterMoveRename?: (toAbsolutePath: string) => void | Promise<void>;
+}
+
+/** One committed file's lifecycle status and line accounting. */
+export interface CommittedFile {
+  readonly path: string;
+  readonly status: "A" | "M" | "R" | "D";
+  /** Original path for a rename (`R` only). */
+  readonly fromPath?: string;
+  readonly addedLines: number;
+  readonly removedLines: number;
+  /** New anchors for the changed lines; absent when the member wrote no content. */
+  readonly served?: ServedFileBlock;
+}
+
+/** Commit outcome: the per-file facts on success, the whole failure on rejection. */
+export type CommitPlanResult =
+  | {
+      readonly ok: true;
+      readonly files: readonly CommittedFile[];
+      readonly diff: string;
+      readonly warnings: readonly string[];
+    }
+  | { readonly ok: false; readonly failure: ApplyPatchFailure };
+
+/** Build the served block one committed member owes the model: only its actually changed lines. */
+function servedBlockFor(member: ProcessedEditFile, path: string): ServedFileBlock | undefined {
+  if (member.resultHashes.length === 0) return undefined;
+  // WHY: a success result returns anchors for the changed lines only (§7); the whole-file projection
+  // WHY: made a one-line edit dump every unchanged line back at the model.
+  const diff = genDiff(
+    member.originalNormalized,
+    member.result,
+    0,
+    member.resultHashes,
+    member.originalHashes,
+  );
+  let rows = diff.servedRows;
+  if (rows.length === 0) return undefined;
+  let text: string;
+  if (rows.length > SERVED_ROWS_CAP) {
+    const next = rows[SERVED_ROWS_CAP]!;
+    text =
+      fmtServedRows(rows.slice(0, SERVED_ROWS_CAP), visLines(member.result)) +
+      "\n" +
+      paginationHint(next.position + 1, rows.length - SERVED_ROWS_CAP);
+    rows = rows.slice(0, SERVED_ROWS_CAP);
+  } else {
+    text = fmtServedRows(rows, visLines(member.result));
+  }
+  return { path, rows, text };
+}
+
+/** Map a commit-stage thrown value onto the apply-patch failure shape. */
+function failureOf(
+  error: unknown,
+  plan: PatchPlan,
+  recovery: TransactionRecoveryReport | undefined,
+): ApplyPatchFailure {
+  const code = error instanceof DomainError ? error.code : "E_UNKNOWN";
+  const baseMessage = error instanceof Error ? error.message : String(error);
+  const patchLine = plan.files[0]?.mutations[0]?.patchLine ?? 1;
+  const recoveryText =
+    recovery === undefined
+      ? ""
+      : "\nRecovery: restored [" +
+        recovery.restored.join(", ") +
+        "], remaining [" +
+        recovery.remaining.join(", ") +
+        "], uncertain [" +
+        recovery.uncertain.join(", ") +
+        "].";
+  const problem: PatchProblem = { code, patchLine, message: baseMessage + recoveryText };
+  return {
+    ok: false,
+    code,
+    message: "apply_patch commit failed: " + baseMessage + recoveryText,
+    problems: [problem],
+    served: [],
+    changedNothing: recovery === undefined || recovery.remaining.length === 0,
+    ...(recovery !== undefined ? { recovery } : {}),
+  };
+}
+
+/**
+ * Commit one plan atomically (one correlated transaction, one undo record set).
+ *
+ * The implementation reuses `commitTransaction` — the existing correlated skeleton — and extends
+ * its member shape with the plan's lifecycle action; the undo schema gains the matching action.
+ *
+ * @param plan - the fully resolved plan.
+ * @param options - cwd/session/store, cancellation and the test fault seams.
+ * @returns the committed facts, or a failure whose `changedNothing` reflects the rollback.
+ */
+export async function commitPlan(
+  plan: PatchPlan,
+  options: CommitPlanOptions,
+): Promise<CommitPlanResult> {
+  const entries: MaterializedMember[] = [];
+  for (const planned of plan.files) {
+    if (planned.writes) entries.push(await materializeMember(planned, options.store));
+  }
+  if (entries.length === 0) return { ok: true, files: [], diff: "", warnings: [] };
+  const members = entries.map((entry) => entry.member);
+  try {
+    const outcome = await commitTransaction(
+      members,
+      members,
+      {
+        sessionKey: options.sessionKey,
+        workspaceRoot: options.cwd,
+        ...(options.signal !== undefined ? { signal: options.signal } : {}),
+        ...(options.store !== undefined ? { store: options.store } : {}),
+        ...(options.accessMode !== undefined ? { accessMode: options.accessMode } : {}),
+        ...(options.onBeforeFirstWrite !== undefined
+          ? { onBeforeFirstCutWrite: options.onBeforeFirstWrite }
+          : {}),
+        ...(options.onBetweenWrites !== undefined
+          ? { onCutBetweenWrites: options.onBetweenWrites }
+          : {}),
+        ...(options.onAfterMoveRename !== undefined
+          ? { onAfterMoveRename: options.onAfterMoveRename }
+          : {}),
+      },
+      options.sessionKey,
+    );
+    const files: CommittedFile[] = entries.map((entry) => {
+      const served = servedBlockFor(entry.member, entry.committedPath);
+      return {
+        path: entry.committedPath,
+        status: entry.status,
+        ...(entry.fromPath !== undefined ? { fromPath: entry.fromPath } : {}),
+        addedLines: entry.member.totalAddedLines,
+        removedLines: entry.member.totalRemovedLines,
+        ...(served !== undefined ? { served } : {}),
+      };
+    });
+    return {
+      ok: true,
+      files,
+      diff: outcome.toolResult.details.diff ?? "",
+      warnings: outcome.toolResult.details.warnings ?? [],
+    };
+  } catch (error) {
+    const recovery = (error as Error & { recovery?: TransactionRecoveryReport }).recovery;
+    return { ok: false, failure: failureOf(error, plan, recovery) };
+  }
+}