dsh-hashline-edit 0.1.0 → 0.2.0

package/src/edit-undo.ts

@@ -1,6 +1,4 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { withFileMutationQueue as piFileMutationQueue } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
+import { withFileMutationQueue as piFileMutationQueue } from "./host-utils.js";
 import {
   readUndo,
   writeUndo,
@@ -21,13 +19,14 @@ import {
 import { loadHashStore } from "./hash-store.js";
 import { sessionKeyFor } from "./served-session/session.js";
 import { readBytes, resolveTarget, writeAtomic } from "./fs-write.js";
+import { pruneEmptyDirs, removeFile, renameFile } from "./fs-lifecycle.js";
 import { toCwd } from "./paths.js";
 import { DEFERRED_STORE_SYNC_WARNING } from "./constants.js";
 import { toLF, stripBOM, genDiff, restoreEndings, type LineEnding } from "./edit-diff.js";
 import { visLines, splitLines, errCode } from "./utils.js";
-import { loadP, loadGuide } from "./prompts.js";
 import { buildMetrics, type EditDetails } from "./edit-response.js";
 import { DomainError, withPayloadSubject } from "./domain-errors.js";
+import type { UndoLifecycle } from "./undo-store.js";
 import { ANCHOR_GENERATION, lineHashes } from "./hashline/hash-identity.js";
 
 /**
@@ -68,6 +67,16 @@ export interface UndoEntry {
   rawPre?: string | null;
   /** The anchor generation the stored hashes were derived under (0 = pre-generation). */
   anchorGeneration?: number | null;
+  /** The lifecycle action this entry reverses; absent/null is an ordinary edit. */
+  lifecycle?: UndoLifecycle | null;
+  /** Move: the absolute pre-transaction path. */
+  fromPath?: string | null;
+  /** Move: the absolute committed path. */
+  toPath?: string | null;
+  /** The raw post-transaction text when the commit wrote non-canonical bytes (pure move). */
+  rawPost?: string | null;
+  /** Add: directories the add created, outermost first. */
+  createdDirs?: readonly string[] | null;
 }
 
 export async function saveUndo(
@@ -89,6 +98,11 @@ export async function saveUndo(
       snapshotHash: entry.snapshotHash ?? snapshotHashFor(entry.content),
       transactionId: entry.transactionId ?? null,
       rawPre: entry.rawPre ?? null,
+      lifecycle: entry.lifecycle ?? null,
+      fromPath: entry.fromPath ?? null,
+      toPath: entry.toPath ?? null,
+      rawPost: entry.rawPost ?? null,
+      createdDirs: entry.createdDirs ?? null,
       // WHY: ADR-0031 §4 — forward the payload generation so the store stamp (upsertUndo)
       // WHY: can preserve it on replay; absent (ordinary edit) defaults to ANCHOR_GENERATION there.
       anchorGeneration: entry.anchorGeneration ?? ANCHOR_GENERATION,
@@ -121,7 +135,7 @@ export async function getUndo(path: string): Promise<UndoEntry | undefined> {
       await removeUndo(path);
       return undefined;
     }
-    return {
+    const entry: UndoEntry = {
       content: record.content,
       bom: record.bom,
       originalEnding,
@@ -131,6 +145,15 @@ export async function getUndo(path: string): Promise<UndoEntry | undefined> {
       transactionId: record.transactionId ?? null,
       anchorGeneration: record.anchorGeneration ?? 0,
     };
+    if (record.lifecycle !== null && record.lifecycle !== undefined)
+      entry.lifecycle = record.lifecycle;
+    if (record.fromPath !== null && record.fromPath !== undefined) entry.fromPath = record.fromPath;
+    if (record.toPath !== null && record.toPath !== undefined) entry.toPath = record.toPath;
+    if (record.rawPost !== null && record.rawPost !== undefined) entry.rawPost = record.rawPost;
+    if (record.createdDirs !== null && record.createdDirs !== undefined) {
+      entry.createdDirs = record.createdDirs;
+    }
+    return entry;
   } catch (error) {
     // SAFETY: best-effort undo load — failures return undefined (no history) and caller reports "No undo history"; stale or corrupt store is recoverable on next edit, not silent undefined without log.
     reportDiagnostic("edit-undo", "Failed to load undo entry:", error);
@@ -162,6 +185,16 @@ interface UndoMember {
   rawPre: string | null;
   /** The anchor generation the stored hashes were derived under (0 = pre-generation). */
   anchorGeneration: number;
+  /** Lifecycle action this row reverses; `edit` is the back-compatible default. */
+  lifecycle: UndoLifecycle;
+  /** Move: absolute pre-transaction path. */
+  fromPath: string | null;
+  /** Move: absolute committed path. */
+  toPath: string | null;
+  /** The raw post bytes when the commit wrote a non-canonical image (pure move). */
+  rawPost: string | null;
+  /** Add: the directories the add created, outermost first. */
+  createdDirs: readonly string[];
 }
 
 function toMember(row: UndoRecord & { path: string }, displayPath: string): UndoMember | undefined {
@@ -178,6 +211,11 @@ function toMember(row: UndoRecord & { path: string }, displayPath: string): Undo
     snapshotHash: row.snapshotHash ?? null,
     rawPre: row.rawPre ?? null,
     anchorGeneration: row.anchorGeneration ?? 0,
+    lifecycle: (row.lifecycle as UndoLifecycle | null) ?? "edit",
+    fromPath: row.fromPath ?? null,
+    toPath: row.toPath ?? null,
+    rawPost: row.rawPost ?? null,
+    createdDirs: row.createdDirs ?? [],
   };
 }
 
@@ -236,6 +274,18 @@ async function undoCorrelatedTransaction(
     };
   }
 
+  // WHY: a row whose lifecycle is anything but `edit` reverses a namespace action (add/delete/
+  // WHY: move). Those need path-level restore steps, not `writeAtomic(pre)`; one lifecycle-aware
+  // WHY: executor handles every member of the batch (including the edit members beside them).
+  if (members.some((m) => m.lifecycle !== "edit")) {
+    return await undoLifecycleTransaction(
+      txnId,
+      requestedAbsolutePath,
+      requestedDisplayPath,
+      members,
+      ctx,
+    );
+  }
   const sessionKeyForUndo = sessionKeyFor(
     // SAFETY: ctx is untyped at the pi boundary — cast validated by pi's runtime shape
     ctx as unknown as { sessionManager?: { getSessionId(): string } },
@@ -563,6 +613,330 @@ async function undoCorrelatedTransaction(
   );
 }
 
+/**
+ * Undo ONE correlated transaction that contains lifecycle members (apply_patch's Add/Delete/Move
+ * batch, possibly beside ordinary text edits). Same durable recipe as `undoCorrelatedTransaction`:
+ * validate every member by BYTES first, land the revert intent before the first write, complete a
+ * partially failed revert inline, fail closed with `E_UNDO_REVERT_FAILED` only when completion is
+ * itself defeated. The namespace steps are the only addition: an add undo removes the created
+ * file (and the empty directories it made), a delete undo re-creates it from the raw pre-image,
+ * and a move undo renames back before restoring the pre bytes.
+ */
+async function undoLifecycleTransaction(
+  txnId: string,
+  requestedAbsolutePath: string,
+  requestedDisplayPath: string,
+  members: UndoMember[],
+  ctx: unknown,
+): Promise<UndoLastEditResult> {
+  const sessionKeyForUndo = sessionKeyFor(
+    // SAFETY: ctx is untyped at the pi boundary — cast validated by pi's runtime shape
+    ctx as unknown as { sessionManager?: { getSessionId(): string } },
+  );
+  const names = members.map((member) => member.displayPath).join(", ");
+  const fileExists = async (path: string): Promise<boolean> => {
+    try {
+      await readBytes(path);
+      return true;
+    } catch (error) {
+      if (errCode(error) === "ENOENT") return false;
+      throw error;
+    }
+  };
+  const stale = (member: UndoMember, reason: "deleted" | "modified"): UndoLastEditResult => ({
+    content: [
+      {
+        type: "text" as const,
+        text: new DomainError("E_UNDO_STALE", { path: member.displayPath, reason }).message,
+      },
+    ],
+    isError: true,
+    details: {},
+  });
+
+  return withSortedMutationQueues(
+    members.map((member) => member.absolutePath),
+    async () => {
+      // WHY: STEP 1 — validate EVERY member before reverting ANY. A delete row's post state
+      // WHY: is "absent"; every other row's post state is its bytes. A move's pre path must not exist.
+      for (const member of members) {
+        const committedPath =
+          member.lifecycle === "move"
+            ? (member.toPath ?? member.absolutePath)
+            : member.absolutePath;
+        if (member.lifecycle === "delete") {
+          if (await fileExists(committedPath)) return stale(member, "modified");
+          continue;
+        }
+        let bytes: Buffer;
+        try {
+          bytes = await readBytes(committedPath);
+        } catch (error) {
+          if (errCode(error) === "ENOENT") return stale(member, "deleted");
+          throw error;
+        }
+        const expectedPost =
+          member.rawPost !== null
+            ? Buffer.from(member.rawPost, "utf-8")
+            : Buffer.from(
+                member.bom + restoreEndings(member.resultContent, member.ending),
+                "utf-8",
+              );
+        if (!bytes.equals(expectedPost)) return stale(member, "modified");
+        if (member.lifecycle === "move" && member.fromPath !== null) {
+          if (await fileExists(member.fromPath)) return stale(member, "modified");
+        }
+      }
+
+      // WHY: STEP 2 — prepare every restore IN MEMORY (no write side touched yet).
+      interface RestorePlan {
+        member: UndoMember;
+        restorePath: string;
+        restoreBytes: Buffer | null;
+        removeOnly: boolean;
+        moveFrom: string | null;
+        moveTo: string | null;
+        dirs: readonly string[];
+        content: string;
+        currentNormalized: string;
+        diff: string;
+        servedRows: ServedRow[];
+        restoredContentHash: string;
+        restoredLineCount: number;
+        restoredHashes: string[];
+        displacedAnchors: string[];
+      }
+      const plans: RestorePlan[] = [];
+      for (const member of members) {
+        const isDelete = member.lifecycle === "delete";
+        const isAdd = member.lifecycle === "add";
+        const isMove = member.lifecycle === "move";
+        const committedPath = isMove ? (member.toPath ?? member.absolutePath) : member.absolutePath;
+        const restorePath = isMove ? (member.fromPath ?? member.absolutePath) : member.absolutePath;
+        const currentNormalized = isDelete ? "" : member.resultContent;
+        const content = isDelete || isMove || !isAdd ? member.content : "";
+        const storedIsCurrentGeneration = member.anchorGeneration === ANCHOR_GENERATION;
+        const restoredContentHash =
+          storedIsCurrentGeneration && member.lifecycle !== "add"
+            ? (member.snapshotHash ?? snapshotHashFor(content))
+            : snapshotHashFor(content);
+        const restoredLineCount = visLines(content).length;
+        let restoredHashes: string[] = [];
+        if (!isAdd) {
+          try {
+            restoredHashes = await restoreHashes(content, restorePath);
+          } catch (error) {
+            reportDiagnostic("edit-undo", "Failed to derive lifecycle restore anchors:", error);
+            restoredHashes = [];
+          }
+        }
+        const currentHashes = isAdd
+          ? await restoreHashes(member.resultContent, committedPath)
+          : isDelete
+            ? []
+            : await restoreHashes(member.resultContent, restorePath);
+        const undoDenseRows = denseServeRows(restoredHashes);
+        const curSet = new Set(currentHashes);
+        const restoredSet = new Set(restoredHashes);
+        const displacedAnchors = [...curSet].filter((hash) => !restoredSet.has(hash));
+        const undoDiff = isAdd
+          ? genDiff(currentNormalized, "", 1, [], currentHashes).diff
+          : isDelete
+            ? genDiff("", content, 1, restoredHashes, []).diff
+            : genDiff(currentNormalized, content, 1, restoredHashes, currentHashes).diff;
+        const restoreBytes = isAdd
+          ? null
+          : member.rawPre !== null
+            ? Buffer.from(member.rawPre, "utf-8")
+            : Buffer.from(member.bom + restoreEndings(content, member.ending), "utf-8");
+        plans.push({
+          member,
+          restorePath,
+          restoreBytes,
+          removeOnly: isAdd,
+          moveFrom: isMove ? restorePath : null,
+          moveTo: isMove ? committedPath : null,
+          dirs: member.createdDirs,
+          content,
+          currentNormalized,
+          diff: undoDiff,
+          servedRows: undoDenseRows,
+          restoredContentHash,
+          restoredLineCount,
+          restoredHashes,
+          displacedAnchors,
+        });
+      }
+
+      // WHY: STEP 3 — durable revert intent BEFORE the first write.
+      await saveCutIntent(txnId, requestedAbsolutePath, "revert");
+      const undoCtx = ctx as { onBeforeUndoWrites?: () => void | Promise<void> };
+      if (undoCtx?.onBeforeUndoWrites) await undoCtx.onBeforeUndoWrites();
+
+      // WHY: STEP 4 — apply the restore steps; a failed step first COMPLETES the remaining members.
+      const applyRestore = async (plan: RestorePlan): Promise<void> => {
+        if (plan.removeOnly) {
+          if (await fileExists(plan.restorePath)) await removeFile(plan.restorePath);
+          await pruneEmptyDirs(plan.dirs);
+          return;
+        }
+        if (plan.moveFrom !== null && plan.moveTo !== null) {
+          if (await fileExists(plan.moveTo)) await renameFile(plan.moveTo, plan.moveFrom);
+        }
+        if (plan.restoreBytes !== null) await writeAtomic(plan.restorePath, plan.restoreBytes);
+      };
+      const reverted = new Set<string>();
+      let defeated: UndoMember | undefined;
+      for (const plan of plans) {
+        try {
+          await applyRestore(plan);
+          reverted.add(plan.member.absolutePath);
+        } catch (error) {
+          reportDiagnostic(
+            "edit-undo",
+            "Lifecycle undo write failed; completing the revert:",
+            error,
+          );
+          for (const rest of plans) {
+            if (reverted.has(rest.member.absolutePath)) continue;
+            try {
+              await applyRestore(rest);
+              reverted.add(rest.member.absolutePath);
+            } catch (completionError) {
+              reportDiagnostic(
+                "edit-undo",
+                "Failed to complete the interrupted lifecycle revert:",
+                completionError,
+              );
+              defeated ??= rest.member;
+            }
+          }
+          break;
+        }
+      }
+      if (defeated !== undefined) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: new DomainError("E_UNDO_REVERT_FAILED", { path: defeated.displayPath }).message,
+            },
+          ],
+          isError: true,
+          details: {},
+        };
+      }
+
+      // WHY: STEP 5 — store commit for every restored file (a removed add owns no snapshot).
+      const deferredSyncWarnings: string[] = [];
+      const servedRowsAll: ServedRow[] = [];
+      const sections: { plan: RestorePlan }[] = [];
+      for (const plan of plans) {
+        if (plan.removeOnly) {
+          sections.push({ plan });
+          continue;
+        }
+        try {
+          await adoptPinnedSnapshotFor(
+            {
+              path: plan.restorePath,
+              snapshotHash: plan.restoredContentHash,
+              lineCount: plan.restoredLineCount,
+              hashes: plan.restoredHashes,
+              content: plan.content,
+            },
+            {
+              retireLeases: true,
+              leases: { sessionKey: sessionKeyForUndo, rows: plan.servedRows },
+              servedMirror: {
+                sessionKey: sessionKeyForUndo,
+                rows: plan.servedRows,
+                shape: { lineCount: plan.restoredLineCount, clearFrom: 0 },
+                retireAnchors: plan.displacedAnchors,
+              },
+            },
+          );
+        } catch (error) {
+          reportDiagnostic("edit-undo", "Failed to commit the lifecycle undo restore:", error);
+          deferredSyncWarnings.push(DEFERRED_STORE_SYNC_WARNING);
+        }
+        servedRowsAll.push(...plan.servedRows);
+        sections.push({ plan });
+      }
+
+      await clearUndoTransaction(txnId);
+      try {
+        await dropCutIntent(txnId);
+      } catch (error) {
+        reportDiagnostic("edit-undo", "Failed to clear the revert intent after commit:", error);
+      }
+
+      const parts: string[] = ["Undone last edit on " + names + "."];
+      for (const { plan } of sections) {
+        switch (plan.member.lifecycle) {
+          case "add":
+            parts.push("Removed the created file " + plan.member.displayPath + ".");
+            break;
+          case "delete":
+            parts.push("Restored the deleted file " + plan.member.displayPath + ".");
+            break;
+          case "move":
+            parts.push(
+              "Moved " +
+                (plan.member.toPath ?? plan.member.absolutePath) +
+                " back to " +
+                plan.restorePath +
+                ".",
+            );
+            break;
+          default:
+            break;
+        }
+      }
+      parts.push(
+        deferredSyncWarnings.length > 0
+          ? "Files reverted; store synchronization is deferred (see the warning below)."
+          : "Files reverted; diff rows carry fresh anchors for follow-up edits.",
+      );
+      parts.push(...deferredSyncWarnings);
+
+      const totalAdded = plans.reduce(
+        (total, plan) =>
+          total +
+          Math.max(0, visLines(plan.content).length - visLines(plan.currentNormalized).length),
+        0,
+      );
+      const totalRemoved = plans.reduce(
+        (total, plan) =>
+          total +
+          Math.max(0, visLines(plan.currentNormalized).length - visLines(plan.content).length),
+        0,
+      );
+      const details: EditDetails = {
+        diff: sections
+          .map(({ plan }) => "--- " + plan.restorePath + " ---\n" + plan.diff)
+          .join("\n"),
+        resultLineCount: visLines(plans[0]!.content).length,
+        servedRows: servedRowsAll,
+        contentHash: plans[0]!.restoredContentHash,
+        ...(deferredSyncWarnings.length > 0 ? { warnings: deferredSyncWarnings } : {}),
+        metrics: buildMetrics({
+          classification: "applied",
+          editsAttempted: plans.length,
+          noopEditsCount: 0,
+          warningsCount: deferredSyncWarnings.length,
+          addedLines: totalAdded,
+          removedLines: totalRemoved,
+        }),
+      };
+      return {
+        content: [{ type: "text" as const, text: parts.join("\n") }],
+        details,
+      };
+    },
+  );
+}
+
 /**
  * Execution facts one host supplies for the undo use case: the directory relative `path` resolves
  * against, and the session whose served anchors the restore re-leases.
@@ -884,23 +1258,3 @@ export async function executeUndoLastEdit(
     throw withPayloadSubject(error, "undo_last_edit");
   }
 }
-
-export function regEditUndo(pi: ExtensionAPI): void {
-  pi.registerTool({
-    name: "undo_last_edit",
-    label: "Undo Last Edit",
-    description: loadP("../prompts/undo-last-edit.md"),
-    promptSnippet: loadP("../prompts/undo-last-edit-snippet.md"),
-    promptGuidelines: loadGuide("../prompts/undo-last-edit-guidelines.md"),
-    parameters: Type.Object({
-      path: Type.String({
-        description: "Path to the file to undo",
-      }),
-    }),
-
-    // WHY: the registration owns only the pi wire shape; the use case lives in the host-agnostic seam.
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      return executeUndoLastEdit(params, ctx as unknown as UndoLastEditContext);
-    },
-  });
-}

package/src/file-content/detection.ts

@@ -288,6 +288,40 @@ async function loadFileKindAndTextViaIo(
   };
 }
 
+/**
+ * Decode a whole file image as strict UTF-8, stripping a UTF-8 BOM.
+ *
+ * WHY this helper exists after the multi-encoding governance was removed: the host
+ * layer reads files as UTF-8 only, but it still has to name a non-UTF-8 target as
+ * such instead of handing the model replacement characters. A fatal decode is the
+ * admission test — the bytes are either UTF-8 or they are refused here, and the
+ * UTF-8 BOM is the one BOM the text keeps meaning for, stripped so it never
+ * reaches a line anchor.
+ *
+ * The refusal is a model-facing fact plus the next action (the user decides how to
+ * convert the file): the message names the path and tells the model to ask.
+ * @param path - the model-supplied path, used verbatim in the refusal.
+ * @returns the decoded text without a BOM character.
+ * @throws DomainError `E_UNSUPPORTED_FILE` when the bytes are not valid UTF-8.
+ */
+export function decodeUtf8Strict(bytes: Uint8Array, path: string): string {
+  // WHY: the leading-BOM skip below and `TextDecoder`'s own BOM rule agree, so a
+  // WHY: UTF-8 BOM can never reach the first line's anchor text.
+  const payload =
+    bytes.length >= 3 && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf
+      ? bytes.subarray(3)
+      : bytes;
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(payload);
+  } catch {
+    throw new DomainError("E_UNSUPPORTED_FILE", {
+      path,
+      kind: "binary",
+      description:
+        "not UTF-8 text; this build reads and writes UTF-8 only — ask the user how to handle this file",
+    });
+  }
+}
 /**
  * The non-printable control characters of the I2 byte-view notice (spec §6): C0 except the three
  * text whitespaces (\t, \n, \r) that render as layout, plus DEL and the C1 block. These are the

package/src/file-content/index.ts

@@ -32,10 +32,10 @@ import {
 } from "./preview.js";
 import { findStatSnapshotFor } from "../snapshot-store";
 import type { ServedRow } from "../served-session/serve-render.js";
-import type { TruncationResult } from "@earendil-works/pi-coding-agent";
+import type { TruncationResult } from "../host-utils.js";
 
 export type { FileStats, LFile, LoadFileOptions } from "./detection.js";
-export { loadFileKindAndText } from "./detection.js";
+export { decodeUtf8Strict, loadFileKindAndText } from "./detection.js";
 export {
   readNormFile,
   decodeNormText,

package/src/file-content/preview.ts

@@ -4,7 +4,7 @@ import {
   DEFAULT_MAX_LINES,
   DEFAULT_MAX_BYTES,
   type TruncationResult,
-} from "@earendil-works/pi-coding-agent";
+} from "../host-utils.js";
 import { MAX_READ_WINDOWS, MAX_READ_WINDOWS_MESSAGE } from "../constants.js";
 import { DomainError } from "../domain-errors.js";
 import {

package/src/file-content/served-header.ts

@@ -5,7 +5,7 @@
  * WHY: one result. Both builders live here, so a header's shape has ONE definition site and the footer
  * WHY: they replaced cannot come back from a call site.
  */
-import { formatSize } from "@earendil-works/pi-coding-agent";
+import { formatSize } from "../host-utils.js";
 
 /** The lines a page rendered, 1-based and inclusive. */
 interface RenderedRange {