jaitus 0.3.12 → 0.3.13

package/src/rewind.js

@@ -1,148 +1,149 @@
-// ─── Rewind: go back to any earlier turn ────────────────────────────────────────
-//
-// Esc+Esc rewinds the conversation to a previous point — and restores the files as
-// they were. The mechanism is simple and honest: before each user prompt
-// is processed, snapshot the message history; before any write/edit command the agent
-// makes, snapshot the file it is about to touch. Restoring a checkpoint then means
-// truncating the message array and copying the file bytes back.
-//
-// Snapshots live in memory for the session's life: this is undo, not backup. Files are
-// capped (count and size) so one `run_command` that rewrites a giant file cannot eat
-// the heap.
-
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-
-const MAX_FILE_SNAPSHOTS = 60;
-const MAX_FILE_BYTES = 2_000_000;
-
-/**
- * The rewind journal for one session. Kept per-session so two windows on the same
- * project never share checkpoints.
- */
-export function createJournal() {
-  const checkpoints = []; // { seq, at, prompt, messages, files }
-  const fileSnapshots = []; // newest last, global cap
-  let seqCounter = 0;
-
-  return {
-    /** Snapshot the conversation before a user prompt is processed. */
-    checkpoint(messages, files = []) {
-      // Checkpoints are full deep clones with NO size cap (only file snapshots are
-      // capped above) — with pasted images in history, 60 checkpoints of megabytes
-      // of base64 each is a straight road to heap death. Past the cap the CHECKPOINT
-      // copy keeps its structure but drops the pixels (live messages are untouched):
-      // rewinding across an image restores a note, not the pixels. Undo stays usable
-      // instead of OOMing the session.
-      const MAX_CHECKPOINT_BYTES = 4_000_000;
-      let snap;
-      try {
-        const raw = JSON.stringify(messages);
-        snap = raw.length > MAX_CHECKPOINT_BYTES
-          ? JSON.parse(JSON.stringify(messages, (key, value) =>
-              (key === 'data' && typeof value === 'string' && value.length > 100_000
-                ? '[image data omitted from checkpoint]' : value)))
-          : JSON.parse(raw);
-      } catch {
-        snap = [];
-      }
-      checkpoints.push({
-        seq: ++seqCounter,
-        at: new Date().toISOString(),
-        prompt: messages.filter((m) => m.role === 'user' && typeof m.content === 'string').at(-1)?.content?.slice(0, 120) || '',
-        messages: snap,
-        files,
-      });
-      if (checkpoints.length > 60) checkpoints.shift();
-    },
-
-    /** Remember a file's current bytes before the agent overwrites it. */
-    snapshotFile(absPath) {
-      if (fileSnapshots.length >= MAX_FILE_SNAPSHOTS) fileSnapshots.shift();
-      const seq = ++seqCounter; // monotonic: immune to clock granularity
-      const takenAt = new Date().toISOString();
-      try {
-        const stat = fs.statSync(absPath);
-        if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return;
-        fileSnapshots.push({ path: absPath, data: fs.readFileSync(absPath), takenAt, seq });
-      } catch {
-        // Unreadable or vanished — restoring means deleting it if it exists now.
-        fileSnapshots.push({ path: absPath, data: null, takenAt, seq });
-      }
-    },
-
-    /**
-     * Snapshot every file this journal has already seen, plus the session save file.
-     * Used before run_command: the shell can touch anything, but re-snapshotting
-     * known files is bounded and covers the session's own blast radius.
-     */
-    snapshotTracked(cwd) {
-      for (const snap of fileSnapshots) {
-        try { this.snapshotFile(snap.path); } catch { /* already counted */ }
-      }
-      try { this.snapshotFile(path.join(cwd, '.jaitus', 'session.json')); } catch { /* fine */ }
-    },
-
-    /**
-     * The most recent snapshot of one path, as text.
-     *
-     * The journal already holds what a file looked like before the agent touched it,
-     * which is exactly the "before" side of a diff — so showing what an edit actually
-     * did costs a lookup rather than a second read of the disk.
-     */
-    latestSnapshot(absPath) {
-      for (let i = fileSnapshots.length - 1; i >= 0; i--) {
-        if (fileSnapshots[i].path === absPath) {
-          return fileSnapshots[i].data ? fileSnapshots[i].data.toString('utf8') : '';
-        }
-      }
-      return null;
-    },
-
-    /** Turn summaries for the rewind dialog, oldest first. */
-    list() {
-      return checkpoints.map((cp, i) => ({ index: i, at: cp.at, prompt: cp.prompt, files: cp.files.length }));
-    },
-
-    /**
-     * Restore checkpoint `index`: truncate messages to that point and restore every
-     * file the agent changed after it. Returns what happened, for the transcript.
-     */
-    restore(index, messages) {
-      const cp = checkpoints[index];
-      if (!cp) return { ok: false, error: 'No such checkpoint.' };
-      const restored = [];
-      const deleted = [];
-      for (const snap of [...fileSnapshots].reverse()) {
-        if (snap.seq <= cp.seq) continue;
-        try {
-          if (snap.data) {
-            fs.mkdirSync(path.dirname(snap.path), { recursive: true });
-            fs.writeFileSync(snap.path, snap.data);
-            restored.push(snap.path);
-          } else if (fs.existsSync(snap.path)) {
-            fs.rmSync(snap.path);
-            deleted.push(snap.path);
-          }
-        } catch { /* best effort per file */ }
-      }
-      messages.length = 0;
-      messages.push(...JSON.parse(JSON.stringify(cp.messages)));
-      return { ok: true, restored, deleted, messageCount: cp.messages.length };
-    },
-
-    /** Drop all checkpoints (new session, /clear). */
-    reset() {
-      checkpoints.length = 0;
-      fileSnapshots.length = 0;
-    },
-  };
-}
-
-/** Human-friendly absolute-path display (short home, forward slashes). */
-export function displayPath(p) {
-  const home = os.homedir();
-  const s = String(p || '');
-  return s.startsWith(home) ? `~${s.slice(home.length)}` : s;
-}
+// ─── Rewind: go back to any earlier turn ────────────────────────────────────────
+//
+// Esc+Esc rewinds the conversation to a previous point — and restores the files as
+// they were. The mechanism is simple and honest: before each user prompt
+// is processed, snapshot the message history; before any write/edit command the agent
+// makes, snapshot the file it is about to touch. Restoring a checkpoint then means
+// truncating the message array and copying the file bytes back.
+//
+// Snapshots live in memory for the session's life: this is undo, not backup. Files are
+// capped (count and size) so one `run_command` that rewrites a giant file cannot eat
+// the heap.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const MAX_FILE_SNAPSHOTS = 60;
+const MAX_FILE_BYTES = 2_000_000;
+
+/**
+ * The rewind journal for one session. Kept per-session so two windows on the same
+ * project never share checkpoints.
+ */
+export function createJournal() {
+  const checkpoints = []; // { seq, at, prompt, messages, files }
+  const fileSnapshots = []; // newest last, global cap
+  let seqCounter = 0;
+
+  return {
+    /** Snapshot the conversation before a user prompt is processed. */
+    checkpoint(messages, files = []) {
+      // Checkpoints are deep clones, and with pasted images in history 60 of them is
+      // megabytes of base64 each. Past the cap the CHECKPOINT copy (never the live
+      // conversation) replaces each large image with a text note: rewinding across it
+      // restores the note, not the pixels. The whole block is replaced, not just its
+      // data — an image block whose data is a sentence is rejected by every provider,
+      // so a rewind used to make every following request fail.
+      const MAX_CHECKPOINT_BYTES = 4_000_000;
+      const NOTE = { type: 'text', text: '[An image was here; it is not kept in undo history.]' };
+      const lighter = (key, value) => (value && typeof value === 'object' && value.type === 'image'
+        && String(value.source?.data || '').length > 100_000 ? NOTE : value);
+      let snap;
+      try {
+        const raw = JSON.stringify(messages);
+        snap = JSON.parse(raw.length > MAX_CHECKPOINT_BYTES ? JSON.stringify(messages, lighter) : raw);
+      } catch {
+        // Too large even to serialise: keep the structure without images rather than
+        // an empty checkpoint, which would rewind the conversation to nothing.
+        try { snap = JSON.parse(JSON.stringify(messages, (k, v) => (v && typeof v === 'object' && v.type === 'image' ? NOTE : v))); } catch { return; }
+      }
+      checkpoints.push({
+        seq: ++seqCounter,
+        at: new Date().toISOString(),
+        prompt: messages.filter((m) => m.role === 'user' && typeof m.content === 'string').at(-1)?.content?.slice(0, 120) || '',
+        messages: snap,
+        files,
+      });
+      if (checkpoints.length > 60) checkpoints.shift();
+    },
+
+    /** Remember a file's current bytes before the agent overwrites it. */
+    snapshotFile(absPath) {
+      if (fileSnapshots.length >= MAX_FILE_SNAPSHOTS) fileSnapshots.shift();
+      const seq = ++seqCounter; // monotonic: immune to clock granularity
+      const takenAt = new Date().toISOString();
+      try {
+        const stat = fs.statSync(absPath);
+        if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return;
+        fileSnapshots.push({ path: absPath, data: fs.readFileSync(absPath), takenAt, seq });
+      } catch {
+        // Unreadable or vanished — restoring means deleting it if it exists now.
+        fileSnapshots.push({ path: absPath, data: null, takenAt, seq });
+      }
+    },
+
+    /**
+     * Snapshot every file this journal has already seen, plus the session save file.
+     * Used before run_command: the shell can touch anything, but re-snapshotting
+     * known files is bounded and covers the session's own blast radius.
+     */
+    snapshotTracked(cwd) {
+      for (const snap of fileSnapshots) {
+        try { this.snapshotFile(snap.path); } catch { /* already counted */ }
+      }
+      try { this.snapshotFile(path.join(cwd, '.jaitus', 'session.json')); } catch { /* fine */ }
+    },
+
+    /**
+     * The most recent snapshot of one path, as text.
+     *
+     * The journal already holds what a file looked like before the agent touched it,
+     * which is exactly the "before" side of a diff — so showing what an edit actually
+     * did costs a lookup rather than a second read of the disk.
+     */
+    latestSnapshot(absPath) {
+      for (let i = fileSnapshots.length - 1; i >= 0; i--) {
+        if (fileSnapshots[i].path === absPath) {
+          return fileSnapshots[i].data ? fileSnapshots[i].data.toString('utf8') : '';
+        }
+      }
+      return null;
+    },
+
+    /** Turn summaries for the rewind dialog, oldest first. */
+    list() {
+      return checkpoints.map((cp, i) => ({ index: i, at: cp.at, prompt: cp.prompt, files: cp.files.length }));
+    },
+
+    /**
+     * Restore checkpoint `index`: truncate messages to that point and restore every
+     * file the agent changed after it. Returns what happened, for the transcript.
+     */
+    restore(index, messages) {
+      const cp = checkpoints[index];
+      if (!cp) return { ok: false, error: 'No such checkpoint.' };
+      const restored = [];
+      const deleted = [];
+      for (const snap of [...fileSnapshots].reverse()) {
+        if (snap.seq <= cp.seq) continue;
+        try {
+          if (snap.data) {
+            fs.mkdirSync(path.dirname(snap.path), { recursive: true });
+            fs.writeFileSync(snap.path, snap.data);
+            restored.push(snap.path);
+          } else if (fs.existsSync(snap.path)) {
+            fs.rmSync(snap.path);
+            deleted.push(snap.path);
+          }
+        } catch { /* best effort per file */ }
+      }
+      messages.length = 0;
+      messages.push(...JSON.parse(JSON.stringify(cp.messages)));
+      return { ok: true, restored, deleted, messageCount: cp.messages.length };
+    },
+
+    /** Drop all checkpoints (new session, /clear). */
+    reset() {
+      checkpoints.length = 0;
+      fileSnapshots.length = 0;
+    },
+  };
+}
+
+/** Human-friendly absolute-path display (short home, forward slashes). */
+export function displayPath(p) {
+  const home = os.homedir();
+  const s = String(p || '');
+  return s.startsWith(home) ? `~${s.slice(home.length)}` : s;
+}