@tiens.nguyen/gu-cli 1.0.768 → 1.0.770

package/workspace-revert.mjs

@@ -0,0 +1,106 @@
+/**
+ * UNDO AN AGENT RUN'S FILE CHANGES — shared by `gu-cli workspace revert` and the terminal's /undo
+ * (task #302).
+ *
+ * Every agent run keeps ~/.gonext/workspace-backups/<runId>/: a copy of each file taken before its
+ * FIRST edit in that run, and manifest.json listing every change (gonext_agent_chat.py
+ * _ws_snapshot / _ws_record_change). Undo puts the ORIGINAL state back.
+ *
+ * WHY A PLAN, NOT A REPLAY. The manifest is a log, and a file can appear in it more than once. The
+ * old revert replayed it in order — so a file the run CREATED and then edited was deleted (the
+ * "create" entry) and then brought back by the "edit" entry's backup, which is a copy of the file
+ * the run had just created. What matters is each path's EARLIEST entry: it says what the file was
+ * before the run touched it. Created → delete it; edited → restore the copy taken before the first
+ * edit; a created folder → remove it only if empty.
+ */
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { copyFile, readFile, rmdir, unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const BACKUPS_ROOT = join(homedir(), ".gonext", "workspace-backups");
+
+/** The manifest's changes → one step per path, from its earliest entry. Pure. */
+export function planRevert(changes) {
+  const first = new Map();
+  for (const c of Array.isArray(changes) ? changes : []) {
+    if (!c || typeof c.path !== "string" || !c.path) continue;
+    if (!first.has(c.path)) first.set(c.path, c);
+  }
+  const steps = [];
+  for (const c of first.values()) {
+    if (c.action === "edit" && c.backup) steps.push({ op: "restore", path: c.path, backup: c.backup });
+    else if (c.action === "create") steps.push({ op: "delete", path: c.path });
+    else if (c.action === "create_dir") steps.push({ op: "rmdir", path: c.path });
+  }
+  // Files before folders, deepest folders first — a created folder can only go once it is empty.
+  const rank = { restore: 0, delete: 0, rmdir: 1 };
+  return steps.sort((a, b) => rank[a.op] - rank[b.op] || (a.op === "rmdir" ? b.path.length - a.path.length : 0));
+}
+
+/** The run directories, oldest first (names are timestamps, so they sort). */
+export function listRuns(root = BACKUPS_ROOT) {
+  try {
+    return readdirSync(root).filter((d) => !d.startsWith(".")).sort();
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * The run a turn produced: the newest run whose manifest was written at or after `sinceMs`.
+ * Every run is one agent process, and every turn is one process — so a run touched after the turn
+ * began belongs to it. null when the turn changed nothing (or ran on another machine).
+ */
+export function runSince(sinceMs, root = BACKUPS_ROOT) {
+  const runs = listRuns(root).reverse();
+  for (const id of runs) {
+    try {
+      if (statSync(join(root, id, "manifest.json")).mtimeMs >= sinceMs - 1000) return id;
+    } catch {
+      /* a run with no manifest changed nothing */
+    }
+  }
+  return null;
+}
+
+/** A run's changes, or null when it has no readable manifest. */
+export async function readRunChanges(runId, root = BACKUPS_ROOT) {
+  try {
+    const m = JSON.parse(await readFile(join(root, runId, "manifest.json"), "utf8"));
+    return Array.isArray(m?.changes) ? m.changes : [];
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Carry out a plan. → { restored, deleted, failed, lines } — `lines` says what happened to each
+ * path, for the caller to print. Never throws; a step that fails is reported and the rest go on.
+ */
+export async function applyRevert(steps, { exists = existsSync } = {}) {
+  let restored = 0, deleted = 0, failed = 0;
+  const lines = [];
+  for (const s of steps) {
+    try {
+      if (s.op === "restore" && exists(s.backup)) {
+        await copyFile(s.backup, s.path);
+        restored += 1;
+        lines.push(`restored ${s.path}`);
+      } else if (s.op === "delete" && exists(s.path)) {
+        await unlink(s.path);
+        deleted += 1;
+        lines.push(`deleted  ${s.path}`);
+      } else if (s.op === "rmdir" && exists(s.path)) {
+        // rmdir removes only an EMPTY folder — undo never destroys what someone put inside later.
+        await rmdir(s.path);
+        deleted += 1;
+        lines.push(`removed  ${s.path}/`);
+      }
+    } catch (err) {
+      failed += 1;
+      lines.push(`FAILED   ${s.path}: ${err.message}`);
+    }
+  }
+  return { restored, deleted, failed, lines };
+}