dsh-hashline-edit 0.1.0 → 0.2.0

package/src/apply-patch/lifecycle.ts

@@ -0,0 +1,195 @@
+import { splitLines } from "../utils.js";
+import { lineHashes } from "../hashline/hash-identity.js";
+import { snapshotIOFor } from "../snapshot-store";
+import { loadHashStore, type HashStore } from "../hash-store.js";
+import type { ProcessedEditFile, MemberLifecycle } from "../mutation-engine/types.js";
+import type { FileBaseline, PatchPath, PlannedFile, PlannedMutation } from "./types.js";
+import { applyPlannedMutations, mutationDelta } from "./plan.js";
+
+/**
+ * apply_patch lifecycle materialization — the plan-to-engine adapter.
+ *
+ * The planner resolves every mutation against a pre-call baseline; this module turns that plan
+ * into the mutation engine's `ProcessedEditFile` member shape (plus the engine-local lifecycle
+ * action). It never writes: the correlated transaction in `mutation-engine/pipeline.ts` owns the
+ * one commit path. Pure text application (splice at baseline coordinates) is the only work here,
+ * and the resulting anchors are always derived under the member's COMMITTED path.
+ *
+ * @module dsh-hashline-edit/apply-patch/lifecycle
+ */
+
+/** One materialized member: the plan facts plus the engine member the commit consumes. */
+export interface MaterializedMember {
+  readonly planned: PlannedFile;
+  readonly member: ProcessedEditFile;
+  readonly status: "A" | "M" | "R" | "D";
+  /** The committed display path (destination for a move; the pre path otherwise). */
+  readonly committedPath: PatchPath;
+  /** The pre-transaction display path (move only). */
+  readonly fromPath?: PatchPath;
+}
+
+/** The union of baseline anchors whose lines this file's mutations retire. */
+function removedHashesOf(
+  baseline: FileBaseline,
+  mutations: readonly PlannedMutation[],
+): Set<string> {
+  const removed = new Set<string>();
+  for (const mutation of mutations) {
+    if (mutation.range.startLine > mutation.range.endLine) continue;
+    for (let line = mutation.range.startLine; line <= mutation.range.endLine; line++) {
+      const hash = baseline.hashes[line - 1];
+      if (hash !== undefined) removed.add(hash);
+    }
+  }
+  return removed;
+}
+
+/** Sum the semantic line counts one materialized member reports (context lines excluded). */
+function countMutationLines(
+  baselineLines: readonly string[],
+  mutations: readonly PlannedMutation[],
+): {
+  added: number;
+  removed: number;
+} {
+  let added = 0;
+  let removed = 0;
+  for (const mutation of mutations) {
+    const delta = mutationDelta(baselineLines, mutation);
+    added += delta.added;
+    removed += delta.removed;
+  }
+  return { added, removed };
+}
+
+/** The engine lifecycle action for one planned file. */
+function lifecycleOf(planned: PlannedFile): MemberLifecycle {
+  switch (planned.lifecycle.kind) {
+    case "keep":
+      return { kind: "keep" };
+    case "add":
+      return { kind: "add", createdDirs: [] };
+    case "delete":
+      return { kind: "delete" };
+    case "move":
+      return {
+        kind: "move",
+        fromAbsolutePath: planned.absolutePath,
+        toAbsolutePath: planned.lifecycle.toAbsolutePath,
+        createdDirs: [],
+      };
+  }
+}
+
+/** The absolute path a member commits to (a move commits at its destination). */
+function committedAbsolutePath(planned: PlannedFile): string {
+  return planned.lifecycle.kind === "move"
+    ? planned.lifecycle.toAbsolutePath
+    : planned.absolutePath;
+}
+
+/** The display path a member commits to. */
+function committedDisplayPath(planned: PlannedFile): PatchPath {
+  return planned.lifecycle.kind === "move" ? planned.lifecycle.to : planned.path;
+}
+
+/**
+ * Derive the member's result anchors under its COMMITTED path.
+ *
+ * Anchors are file-scoped (the path seeds the derivation), so a move must re-derive at the
+ * destination instead of carrying the source's anchors across. An in-place edit keeps the
+ * baseline's surviving anchors through the engine's prior-identity seam.
+ */
+async function resultHashesFor(
+  planned: PlannedFile,
+  result: string,
+  store?: HashStore,
+): Promise<string[]> {
+  if (planned.lifecycle.kind === "delete") return [];
+  const resolvedStore = store ?? (await loadHashStore());
+  const path = committedAbsolutePath(planned);
+  const previous =
+    planned.lifecycle.kind === "keep"
+      ? {
+          content: planned.baseline.text,
+          hashes: [...planned.baseline.hashes],
+          removedHashes: removedHashesOf(planned.baseline, planned.mutations),
+        }
+      : undefined;
+  return lineHashes(result, path, previous, snapshotIOFor(resolvedStore), false);
+}
+
+/** The status letter one member reports in the success summary. */
+function statusOf(planned: PlannedFile): "A" | "M" | "R" | "D" {
+  switch (planned.lifecycle.kind) {
+    case "add":
+      return "A";
+    case "delete":
+      return "D";
+    case "move":
+      return "R";
+    case "keep":
+      return "M";
+  }
+}
+
+/**
+ * Materialize one planned file into the engine's member shape.
+ *
+ * The result text is produced by applying the plan's baseline-coordinate mutations; the anchors
+ * are then derived under the committed path. No file is read or written here — the plan already
+ * carries every baseline byte the commit needs.
+ */
+export async function materializeMember(
+  planned: PlannedFile,
+  store?: HashStore,
+): Promise<MaterializedMember> {
+  const lifecycle = planned.lifecycle;
+  const isDelete = lifecycle.kind === "delete";
+  const isEmptyBaseline = planned.baseline.text === "" && planned.baseline.hashes.length === 0;
+  const baselineLines = isEmptyBaseline ? [] : splitLines(planned.baseline.text);
+  const resultLines = isDelete ? [] : applyPlannedMutations(baselineLines, planned.mutations);
+  const result = isDelete
+    ? ""
+    : isEmptyBaseline
+      ? resultLines.length === 0
+        ? ""
+        : resultLines.join("\n") + "\n"
+      : resultLines.join("\n") + (planned.baseline.text.endsWith("\n") ? "\n" : "");
+  const resultHashes = isDelete ? [] : await resultHashesFor(planned, result, store);
+  const { added, removed } = isDelete
+    ? { added: 0, removed: baselineLines.length }
+    : countMutationLines(baselineLines, planned.mutations);
+  const member: ProcessedEditFile = {
+    path: planned.path,
+    absolutePath: committedAbsolutePath(planned),
+    originalNormalized: lifecycle.kind === "add" ? "" : planned.baseline.text,
+    result,
+    bom: planned.baseline.bom,
+    originalEnding: planned.baseline.ending,
+    warnings: [],
+    originalHashes: [...planned.baseline.hashes],
+    resultHashes,
+    resultLineIds: [],
+    removedHashes: removedHashesOf(planned.baseline, planned.mutations),
+    appliedCount: 1,
+    noopCount: 0,
+    totalAddedLines: added,
+    totalRemovedLines: removed,
+    driftNotice: undefined,
+    range: { startLine: 1, endLine: 1, startHash: "", endHash: "", delta: 0 },
+    editedIntervals: [],
+    literalDeclarations: 0,
+    foreignCuts: [],
+    lifecycle: lifecycleOf(planned),
+  };
+  const fromPath = lifecycle.kind === "move" ? planned.path : undefined;
+  return {
+    planned,
+    member,
+    status: statusOf(planned),
+    committedPath: committedDisplayPath(planned),
+    ...(fromPath !== undefined ? { fromPath } : {}),
+  };
+}