@jerryan/pi-hashline-edit 0.7.3 → 0.8.1

package/src/undo.ts

@@ -0,0 +1,212 @@
+import { Text } from "@earendil-works/pi-tui";
+import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { constants } from "fs";
+import { readFileSync } from "fs";
+import { access as fsAccess } from "fs/promises";
+import {
+  detectLineEnding,
+  generateDiffString,
+  normalizeToLF,
+  restoreLineEndings,
+  stripBom,
+} from "./edit-diff";
+import { resolveMutationTargetPath, writeFileAtomically } from "./fs-write";
+import { loadFileKindAndText } from "./file-kind";
+import { resolveToCwd } from "./path-utils";
+import { throwIfAborted } from "./runtime";
+import { getFileSnapshot } from "./snapshot";
+import { buildChangedResponse } from "./edit-response";
+import { PACKAGE_INFO } from "./package-info";
+
+const UNDO_DESC = readFileSync(
+  new URL("../tool-descriptions/undo.md", import.meta.url),
+  "utf-8",
+).trim();
+
+/** Maximum number of turns after which undo becomes unavailable.
+ *  Allows patterns like edit -> read -> undo, but prevents undoing
+ *  edits from distant conversation history. */
+const MAX_UNDO_TURNS = 3;
+
+export type LastEdit = {
+  path: string;
+  previousContent: string;
+  turnIndex: number;
+};
+
+let lastEdit: LastEdit | undefined;
+let currentTurnIndex = 0;
+
+export function setCurrentTurn(index: number): void {
+  currentTurnIndex = index;
+}
+
+export function setLastEdit(entry: Omit<LastEdit, "turnIndex">): void {
+  lastEdit = { ...entry, turnIndex: currentTurnIndex };
+}
+
+export function getLastEdit(): LastEdit | undefined {
+  return lastEdit;
+}
+
+export function clearLastEdit(): void {
+  lastEdit = undefined;
+}
+
+const undoToolSchema = Type.Object({}, { additionalProperties: false });
+
+type UndoToolDetails = {
+  diff: string;
+  snapshotId?: string;
+  package: { name: string; version: string };
+};
+
+function colorDiffLines(
+  lines: string[],
+  theme: { fg: (token: string, text: string) => string },
+): string[] {
+  return lines.map((line) => {
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      return theme.fg("success", line);
+    }
+    if (line.startsWith("-") && !line.startsWith("---")) {
+      return theme.fg("error", line);
+    }
+    return theme.fg("dim", line);
+  });
+}
+
+const undoToolDefinition: ToolDefinition<
+  typeof undoToolSchema,
+  UndoToolDetails
+> & { renderShell?: "default" | "self" } = {
+  name: "undo",
+  label: "Undo",
+  description: UNDO_DESC,
+  parameters: undoToolSchema,
+  renderShell: "default",
+
+  renderCall(_args, theme, _context) {
+    return new Text(
+      `${theme.fg("toolTitle", "undo")} ${theme.fg("toolOutput", "revert last edit")}`,
+      0,
+      0,
+    );
+  },
+
+  renderResult(result, { isPartial }, theme, _context) {
+    if (isPartial) {
+      return new Text(theme.fg("warning", "Undoing..."), 0, 0);
+    }
+
+    const typedResult = result as {
+      content?: Array<{ type: string; text?: string }>;
+      details?: UndoToolDetails;
+    };
+
+    if (typedResult.details?.diff) {
+      const text = colorDiffLines(
+        typedResult.details.diff.split("\n"),
+        theme,
+      ).join("\n");
+      return new Text(text, 0, 0);
+    }
+
+    const renderedText = typedResult.content?.find(
+      (entry): entry is { type: "text"; text: string } =>
+        entry.type === "text" && typeof entry.text === "string",
+    )?.text;
+
+    if (renderedText) {
+      return new Text(theme.fg("error", renderedText), 0, 0);
+    }
+
+    return new Text("", 0, 0);
+  },
+
+  async execute(_toolCallId, _params, signal, _onUpdate, ctx) {
+    const entry = lastEdit;
+    if (!entry) {
+      throw new Error(
+        "[E_NO_UNDO] No edit to undo. The undo tool only reverts the most recent hashline edit in this session.",
+      );
+    }
+
+    const turnsSinceEdit = currentTurnIndex - entry.turnIndex;
+    if (turnsSinceEdit > MAX_UNDO_TURNS) {
+      throw new Error(
+        `[E_NO_UNDO] The last edit was ${turnsSinceEdit} turns ago. Undo is only available for edits within the last ${MAX_UNDO_TURNS} turns.`,
+      );
+    }
+
+    const path = entry.path;
+    const absolutePath = resolveToCwd(path, ctx.cwd);
+    const mutationTargetPath = await resolveMutationTargetPath(absolutePath);
+
+    return withFileMutationQueue(mutationTargetPath, async () => {
+      throwIfAborted(signal);
+      try {
+        await fsAccess(absolutePath, constants.R_OK | constants.W_OK);
+      } catch (error: unknown) {
+        const code = (error as NodeJS.ErrnoException).code;
+        if (code === "ENOENT") {
+          throw new Error(`File not found: ${path}`);
+        }
+        if (code === "EACCES" || code === "EPERM") {
+          throw new Error(`File is not writable: ${path}`);
+        }
+        throw new Error(`Cannot access file: ${path}`);
+      }
+
+      throwIfAborted(signal);
+      const file = await loadFileKindAndText(absolutePath);
+      if (file.kind !== "text") {
+        throw new Error(
+          `Hashline undo only supports text files. ${path} is ${file.kind}.`,
+        );
+      }
+
+      throwIfAborted(signal);
+      const { bom, text: currentText } = stripBom(file.text);
+      const originalEnding = detectLineEnding(currentText);
+      const currentNormalized = normalizeToLF(currentText);
+      const restoredContent = entry.previousContent;
+
+      if (currentNormalized === restoredContent) {
+        return {
+          content: [{ type: "text", text: "No changes needed. File already matches the pre-edit state." }],
+          details: {
+            diff: "",
+            package: PACKAGE_INFO,
+          },
+        };
+      }
+
+      throwIfAborted(signal);
+      await writeFileAtomically(
+        absolutePath,
+        bom + restoreLineEndings(restoredContent, originalEnding),
+      );
+
+      clearLastEdit();
+      const updatedSnapshotId = (await getFileSnapshot(absolutePath)).snapshotId;
+      const { diff } = generateDiffString(currentNormalized, restoredContent);
+
+      return buildChangedResponse({
+        path,
+        originalNormalized: currentNormalized,
+        result: restoredContent,
+        warnings: [],
+        snapshotId: updatedSnapshotId,
+        editsAttempted: 1,
+        noopEditsCount: 0,
+      });
+    });
+  },
+};
+
+export function registerUndoTool(pi: ExtensionAPI): void {
+  pi.registerTool(undoToolDefinition);
+}

package/{prompts → tool-descriptions}/edit.md

@@ -1,23 +1,23 @@
-Patch a UTF-8 text file using `LINE#HASH` anchors copied verbatim from `read`.
-
-Submit one `edit` call per file. All operations go in a single `edits` array; anchors must come from the same fresh source — the most recent `read` or diff output of a successful `edit` on this file.
-
-Each edit entry replaces an inclusive anchor range:
-```json
-{ "range": [startAnchor, endAnchor], "lines": [...] }
-```
-- `range` — `[start, end]` pair of LINE#HASH anchors from the most recent `read` or diff output.
-  Use the same anchor twice for single-line: `["42#A4", "42#A4"]`.
-- `lines` — new content replacing the range (string array). Use `[]` to delete.
-  Must be literal file content, not LINE#HASH│-prefixed output. Match indentation exactly.
-
-Example:
-```json
-{ "path": "src/main.ts", "edits": [
-  { "range": ["12#3F", "12#3F"], "lines": ["const x = 1;"] },
-  { "range": ["20#B2", "25#C7"], "lines": ["function foo() {", "  return 42;", "}"] }
-] }
-
-Rules:
-- Do not guess, shift, or construct anchors. Copy them from the most recent `read` or diff output of this file.
-- Do not emit overlapping or adjacent edits — merge them into one.
+Patch a UTF-8 text file using `LINE#HASH` anchors copied verbatim from `read`.
+
+Submit one `edit` call per file. All operations go in a single `edits` array; anchors must come from the same fresh source — the most recent `read` or diff output of a successful `edit` on this file.
+
+Each edit entry replaces an inclusive anchor range:
+```json
+{ "range": [startAnchor, endAnchor], "lines": [...] }
+```
+- `range` — `[start, end]` pair of LINE#HASH anchors from the most recent `read` or diff output.
+  Use the same anchor twice for single-line: `["42#A4", "42#A4"]`.
+- `lines` — new content replacing the range (string array). Use `[]` to delete.
+  Must be literal file content, not LINE#HASH│-prefixed output. Match indentation exactly.
+
+Example:
+```json
+{ "path": "src/main.ts", "edits": [
+  { "range": ["12#3F", "12#3F"], "lines": ["const x = 1;"] },
+  { "range": ["20#B2", "25#C7"], "lines": ["function foo() {", "  return 42;", "}"] }
+] }
+
+Rules:
+- Do not guess, shift, or construct anchors. Copy them from the most recent `read` or diff output of this file.
+- Do not emit overlapping or adjacent edits — merge them into one.

package/{prompts → tool-descriptions}/read-guidelines.md

@@ -1,2 +1,2 @@
-- Use read before edit when you do not have current LINE#HASH anchors for the file.
+- Use read before edit when you do not have current LINE#HASH anchors for the file.
 - If read is truncated, continue with the `offset` it suggests — do not guess unseen lines.

package/{prompts → tool-descriptions}/read.md

@@ -1,5 +1,5 @@
-Read a UTF-8 text file or a supported image. Text lines are prefixed `LINE#HASH│content` — copy those anchors verbatim into `edit`.
-
-Use `offset` and `limit` to page through. Default cap: {{DEFAULT_MAX_LINES}} lines or {{DEFAULT_MAX_BYTES}}; when truncated, the tail of the output tells you the next `offset`.
-
-Set `raw: true` to skip LINE#HASH prefixing and return plain text. Don't use if you plan to edit this file — saves tokens on exploration, documentation, and reference reads.
+Read a UTF-8 text file or a supported image. Text lines are prefixed `LINE#HASH│content` — copy those anchors verbatim into `edit`.
+
+Use `offset` and `limit` to page through. Default cap: {{DEFAULT_MAX_LINES}} lines or {{DEFAULT_MAX_BYTES}}; when truncated, the tail of the output tells you the next `offset`.
+
+Set `raw: true` to skip LINE#HASH prefixing and return plain text. Don't use if you plan to edit this file — saves tokens on exploration, documentation, and reference reads.

package/tool-descriptions/undo.md

@@ -0,0 +1,8 @@
+Undo the most recent hashline edit. No parameters.
+
+Use this when an `edit` call corrupted a file and you want to revert it immediately without a full rewrite.
+
+Limitations:
+- Only the most recent edit can be undone. A second `undo` will fail.
+- Undo is only available within 3 turns of the edit. After that, use `read` and `edit` to fix the file.
+- Undo state does not survive session switches, reloads, or restarts.