dsh-hashline-edit 0.1.0 → 0.2.0

package/src/cut-repair.ts

@@ -1,5 +1,6 @@
 import { restoreEndings, type LineEnding } from "./edit-diff.js";
 import { readBytes, writeAtomic } from "./fs-write.js";
+import { pathKind, removeFile, renameFile } from "./fs-lifecycle.js";
 import { withSortedMutationQueues } from "./mutation-queue.js";
 import { errCode } from "./utils.js";
 import { loadHashStore, type HashStore } from "./hash-store.js";
@@ -73,20 +74,87 @@ function candidateFor(row: MemberRow, which: "pre" | "post"): Buffer | undefined
 }
 
 async function stateOf(row: MemberRow): Promise<MemberState> {
-  let bytes: Buffer;
-  try {
-    bytes = await readBytes(row.path);
-  } catch (error) {
-    if (errCode(error) === "ENOENT") return "other";
-    throw error;
-  }
+  const lifecycle = row.lifecycle ?? "edit";
   const post = candidateFor(row, "post");
-  if (post !== undefined && bytes.equals(post)) return "post";
   const pre = candidateFor(row, "pre");
+  const readOrUndefined = async (path: string | null | undefined): Promise<Buffer | undefined> => {
+    if (path === null || path === undefined) return undefined;
+    try {
+      return await readBytes(path);
+    } catch (error) {
+      if (errCode(error) === "ENOENT") return undefined;
+      throw error;
+    }
+  };
+  if (lifecycle === "add") {
+    const bytes = await readOrUndefined(row.path);
+    if (bytes === undefined) return "pre";
+    return post !== undefined && bytes.equals(post) ? "post" : "other";
+  }
+  if (lifecycle === "delete") {
+    const bytes = await readOrUndefined(row.path);
+    if (bytes === undefined) return "post";
+    return pre !== undefined && bytes.equals(pre) ? "pre" : "other";
+  }
+  if (lifecycle === "move") {
+    const to = await readOrUndefined(row.path);
+    const from = await readOrUndefined(row.fromPath);
+    if (to !== undefined && post !== undefined && to.equals(post)) return "post";
+    if (from !== undefined && pre !== undefined && from.equals(pre)) return "pre";
+    // WHY: crash after the rename but before the content rewrite — the destination holds the raw
+    // WHY: pre bytes and the source is gone. That is the PRE state of an as-yet-unapplied move.
+    if (to !== undefined && pre !== undefined && to.equals(pre) && from === undefined) return "pre";
+    return "other";
+  }
+  const bytes = await readOrUndefined(row.path);
+  if (bytes === undefined) return "other";
+  if (post !== undefined && bytes.equals(post)) return "post";
   if (pre !== undefined && bytes.equals(pre)) return "pre";
   return "other";
 }
 
+/** Write one lifecycle row to its named state; returns false when the row cannot express it. */
+async function writeState(row: MemberRow, which: "pre" | "post"): Promise<boolean> {
+  const lifecycle = row.lifecycle ?? "edit";
+  const bytes = candidateFor(row, which);
+  if (lifecycle === "add") {
+    if (which === "post") {
+      if (bytes === undefined) return false;
+      await writeAtomic(row.path, bytes);
+      return true;
+    }
+    if ((await pathKind(row.path)) !== "absent") await removeFile(row.path);
+    return true;
+  }
+  if (lifecycle === "delete") {
+    if (which === "post") {
+      if ((await pathKind(row.path)) !== "absent") await removeFile(row.path);
+      return true;
+    }
+    if (bytes === undefined) return false;
+    await writeAtomic(row.path, bytes);
+    return true;
+  }
+  if (lifecycle === "move") {
+    const source = row.fromPath;
+    if (source === null || source === undefined) return false;
+    if (which === "post") {
+      if ((await pathKind(row.path)) === "absent") {
+        if ((await pathKind(source)) === "absent") return false;
+        await renameFile(source, row.path);
+      }
+      if (bytes !== undefined) await writeAtomic(row.path, bytes);
+      return true;
+    }
+    if ((await pathKind(row.path)) !== "absent") await renameFile(row.path, source);
+    if (bytes !== undefined) await writeAtomic(source, bytes);
+    return true;
+  }
+  if (bytes === undefined) return false;
+  await writeAtomic(row.path, bytes);
+  return true;
+}
+
 /** Returns true when the resolution completed (bytes written or nothing to write) and the intent retired. */
 async function applyResolution(
   store: HashStore,
@@ -106,9 +174,7 @@ async function applyResolution(
         if (now !== expected) return false;
       }
       for (const row of toWrite) {
-        const bytes = candidateFor(row, which);
-        if (bytes === undefined) return false;
-        await writeAtomic(row.path, bytes);
+        if (!(await writeState(row, which))) return false;
       }
       deleteCutIntent(store, txnId);
       return true;

package/src/domain-errors.ts

@@ -54,19 +54,27 @@ export type DomainErrorCode =
   | "E_UNDO_REVERT_FAILED"
   | "E_UNKNOWN"
   | "E_LARGE_FILE"
-  | "E_INTERNAL_INVARIANT";
+  | "E_INTERNAL_INVARIANT"
+  // WHY: apply_patch's two genuinely new codes (E_STALE_ANCHOR already exists above).
+  | "E_PATCH_SYNTAX"
+  | "E_UNIQUE_MATCH";
 
 /**
  * The registered tool whose call produced an `E_BAD_PAYLOAD`. WHY the registered name: the model
  * reads the tool list, so `undo_last_edit` names the call it must repair and a short form would
  * name nothing. A tool belongs here only after a live path is measured, never by assumption.
  */
-export type PayloadSubject = "read" | "edit" | "undo_last_edit";
+export type PayloadSubject = "read" | "edit" | "apply_patch" | "undo_last_edit";
 
 // WHY: this is the runtime companion of the `PayloadSubject` union, like `isDomainErrorCode`.
 // WHY: Only a member may name a tool.
 // WHY: A non-member renders the neutral wording instead.
-const PAYLOAD_SUBJECTS: readonly PayloadSubject[] = ["read", "edit", "undo_last_edit"];
+const PAYLOAD_SUBJECTS: readonly PayloadSubject[] = [
+  "read",
+  "edit",
+  "apply_patch",
+  "undo_last_edit",
+];
 
 export function isPayloadSubject(value: unknown): value is PayloadSubject {
   return typeof value === "string" && (PAYLOAD_SUBJECTS as readonly string[]).includes(value);
@@ -252,6 +260,20 @@ export interface ErrorPayloadMap {
      */
     subject?: PayloadSubject;
   };
+  E_PATCH_SYNTAX: {
+    message: string;
+    path?: string;
+    patchLine?: number;
+    servedRows?: ServedRow[];
+    servedBlock?: string;
+  };
+  E_UNIQUE_MATCH: {
+    message: string;
+    path?: string;
+    patchLine?: number;
+    servedRows?: ServedRow[];
+    servedBlock?: string;
+  };
 }
 
 export interface CodeSpec<P> {
@@ -334,13 +356,29 @@ function largeFileFormat(payload: ErrorPayloadMap["E_LARGE_FILE"]): string {
   return `${where} has ${observed} lines, exceeding the ${payload.limit}-line edit limit.`;
 }
 
+/** SAFETY: one copy of each distinct anchor, in submission order. */
+function distinctAnchors(anchors: readonly string[]): string[] {
+  return [...new Set(anchors)];
+}
+
+/**
+ * SAFETY: render the served evidence section at most once. A producer may hand a headline that
+ * already carries the pre-rendered section (a forwarded rejection); appending the block again would
+ * make the model pay for the same rows twice in the retry round. The `heading` + block pair is the
+ * machine-checkable section, so a bare row echoed inside a headline is not mistreated as one.
+ */
+function appendServedBlock(headline: string, heading: string, servedBlock: string): string {
+  if (servedBlock === "") return headline;
+  if (headline.includes(`${heading}\n${servedBlock}`)) return headline;
+  return `${headline}\n${heading}\n${servedBlock}`;
+}
+
 function staleAnchorFormat(payload: ErrorPayloadMap["E_STALE_ANCHOR"]): string {
-  if (!payload.servedBlock) return payload.headline;
-  return `${payload.headline}\nCurrent range:\n${payload.servedBlock}`;
+  return appendServedBlock(payload.headline, "Current range:", payload.servedBlock ?? "");
 }
 
 function unknownAnchorFormat(payload: ErrorPayloadMap["E_UNKNOWN_ANCHOR"]): string {
-  const anchors = payload.anchors;
+  const anchors = distinctAnchors(payload.anchors);
   if (anchors.length === 1) {
     return `${payload.path} has not served the anchor "${anchors[0]}".`;
   }
@@ -356,13 +394,13 @@ function foreignHomesDisplay(homes: string[]): string {
 }
 
 function foreignAnchorFormat(payload: ErrorPayloadMap["E_FOREIGN_ANCHOR"]): string {
-  const anchors = payload.anchors;
+  const anchors = distinctAnchors(payload.anchors);
   const noun =
     anchors.length === 1
       ? `the anchor "${anchors[0]}"`
       : `the anchors ${anchors.map((a) => `"${a}"`).join(", ")}`;
   const verb = anchors.length === 1 ? "was" : "were";
-  const homes = foreignHomesDisplay(payload.homes);
+  const homes = foreignHomesDisplay([...new Set(payload.homes)]);
   if (homes.length === 0) {
     return `${noun} ${verb} not served for ${payload.path}.`;
   }
@@ -423,7 +461,7 @@ export const ERROR_REGISTRY: { [K in DomainErrorCode]: CodeSpec<ErrorPayloadMap[
       if (servedBlock === "" && headline === "") {
         throw new TypeError("E_STALE_RANGE: headline must be non-empty when servedBlock is empty");
       }
-      return servedBlock === "" ? headline : `${headline}\n${FRESH_READ_HEADING}\n${servedBlock}`;
+      return appendServedBlock(headline, FRESH_READ_HEADING, servedBlock);
     },
   },
   E_TARGET_LOST: {
@@ -445,7 +483,7 @@ export const ERROR_REGISTRY: { [K in DomainErrorCode]: CodeSpec<ErrorPayloadMap[
           "E_UNVERIFIED_RANGE: headline must be non-empty when servedBlock is empty",
         );
       }
-      return servedBlock === "" ? resolved : `${resolved}\n${FRESH_READ_HEADING}\n${servedBlock}`;
+      return appendServedBlock(resolved, FRESH_READ_HEADING, servedBlock);
     },
   },
   E_MALFORMED_ANCHOR: {
@@ -562,6 +600,16 @@ export const ERROR_REGISTRY: { [K in DomainErrorCode]: CodeSpec<ErrorPayloadMap[
     // WHY: no options — read needs `mode: "verbatim"` and edit needs a split, but the payload
     // WHY: names neither tool. Add `subject` before serving advice (ADR-0047).
   },
+  E_PATCH_SYNTAX: {
+    audience: "MODEL",
+    // WHY: the parser already rendered every problem with its patch line; the envelope carries
+    // WHY: that aggregate so one resubmission can fix every syntax problem.
+    format: ({ message }) => message,
+  },
+  E_UNIQUE_MATCH: {
+    audience: "MODEL",
+    format: ({ message }) => message,
+  },
 };
 
 export interface WarningPayloadMap {