mixdog 1.1.1 → 1.2.0

package/src/runtime/shared/turn-snapshot-store.mjs

@@ -14,7 +14,7 @@
 // whole tree, but only these paths may be restored from it.
 import { createHash } from 'node:crypto';
 import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { cleanString as clean } from './clean.mjs';
 import { resolvePluginData } from './plugin-paths.mjs';
 
@@ -131,20 +131,19 @@ async function readRecordFile(path) {
   }
 }
 
-/** Oldest-first sweep so a long-lived install cannot accumulate records. */
-async function sweepRecords() {
-  if (sweepDone) return;
-  sweepDone = true;
+/** Oldest-first sweep of one record directory so a long-lived install cannot
+ *  accumulate records. */
+async function sweepDirectory(directory, ttlMs, maxFiles) {
   try {
-    const names = await readdir(recordRoot());
+    const names = await readdir(directory);
     const now = Date.now();
     const kept = [];
     for (const name of names) {
       if (!name.endsWith('.json')) continue;
-      const path = join(recordRoot(), name);
+      const path = join(directory, name);
       try {
         const info = await stat(path);
-        if (now - info.mtimeMs > RECORD_TTL_MS) {
+        if (now - info.mtimeMs > ttlMs) {
           await rm(path, { force: true });
           continue;
         }
@@ -154,7 +153,7 @@ async function sweepRecords() {
       }
     }
     kept.sort((left, right) => left.mtimeMs - right.mtimeMs);
-    for (const entry of kept.slice(0, Math.max(0, kept.length - MAX_RECORD_FILES))) {
+    for (const entry of kept.slice(0, Math.max(0, kept.length - maxFiles))) {
       await rm(entry.path, { force: true });
     }
   } catch {
@@ -162,6 +161,18 @@ async function sweepRecords() {
   }
 }
 
+async function sweepRecords() {
+  if (sweepDone) return;
+  sweepDone = true;
+  await sweepDirectory(recordRoot(), RECORD_TTL_MS, MAX_RECORD_FILES);
+}
+
+async function writeJsonAtomically(path, payload) {
+  const temporary = `${path}.${process.pid}.tmp`;
+  await writeFile(temporary, JSON.stringify(payload), 'utf8');
+  await rename(temporary, path);
+}
+
 /**
  * Fold one turn into a session's record. `generation` identifies the turn, so
  * re-recording the same turn updates it in place rather than appending.
@@ -219,9 +230,7 @@ export async function saveTurnSnapshotRecord(sessionId, turn) {
           .slice(-MAX_SESSION_SCOPES)
           .map(serializeScope),
       };
-      const temporary = `${path}.${process.pid}.tmp`;
-      await writeFile(temporary, JSON.stringify(payload), 'utf8');
-      await rename(temporary, path);
+      await writeJsonAtomically(path, payload);
       return true;
     } catch {
       return false;
@@ -259,8 +268,333 @@ export async function loadSessionSnapshotRecords(sessionId) {
   return sessionScopes(record).map(serializeScope);
 }
 
+// Absolute, slash-normalized and (on Windows) case-folded: equal for every
+// spelling of one folder, so a stored root and a caller's root compare equal.
+function matchKey(value) {
+  const text = clean(value);
+  if (!text) return '';
+  const key = resolve(text).replace(/\\/g, '/').replace(/\/+$/, '');
+  return process.platform === 'win32' ? key.toLowerCase() : key;
+}
+
+/**
+ * Remove one worktree root from every session record: its turns and its
+ * session scope. Other roots' scopes, turns and the rest of the session history
+ * stay; a record left with nothing is deleted. Serialized with saves through
+ * the per-session chain. The per-turn change records rooted there are marked
+ * unavailable (see forgetChangeRecordsRoot). Returns `{ removed, kept }`:
+ * removed are `<recordFile>#<root>` scopes (or the record file itself once
+ * emptied) and `<changesFile>#<checkpointId>` change records; kept are files
+ * that matched but could not be rewritten.
+ */
+export async function forgetTurnSnapshotRoot(root) {
+  const removed = [];
+  const kept = [];
+  const target = matchKey(root);
+  if (!target) return { removed, kept };
+  let names = [];
+  try {
+    names = await readdir(recordRoot());
+  } catch {
+    return { removed, kept };
+  }
+  for (const name of names) {
+    if (!name.endsWith('.json')) continue;
+    const path = join(recordRoot(), name);
+    const sessionId = clean((await readRecordFile(path))?.sessionId);
+    if (!sessionId) continue;
+    await chain(sessionId, async () => {
+      const record = await readRecordFile(path);
+      if (!record) return;
+      const turns = record.turns.filter((turn) => matchKey(turn?.root) !== target);
+      const scopes = sessionScopes(record);
+      const remaining = scopes.filter((scope) => matchKey(scope.root) !== target);
+      if (turns.length === record.turns.length && remaining.length === scopes.length) return;
+      try {
+        if (turns.length === 0 && remaining.length === 0) {
+          await rm(path, { force: true });
+          removed.push(path);
+          return;
+        }
+        await writeJsonAtomically(path, { ...record, turns, sessionScopes: remaining.map(serializeScope) });
+        removed.push(`${path}#${target}`);
+      } catch {
+        kept.push(path);
+      }
+    });
+  }
+  await forgetChangeRecordsRoot(target, removed, kept);
+  return { removed, kept };
+}
+
+/** Why a change-record file of a removed worktree can no longer be undone or
+ *  reapplied. */
+export const REMOVED_WORKTREE_CHANGE_REASON = 'its worktree was removed';
+
+const unavailableChangeFile = (file) => {
+  const { patch, patchEncoding, patchOmitted, ...rest } = file;
+  return { ...rest, revertable: false, reason: REMOVED_WORKTREE_CHANGE_REASON, patch: null };
+};
+
+const changeFileUnavailable = (file) =>
+  file.revertable === false && file.reason === REMOVED_WORKTREE_CHANGE_REASON && file.patch === null;
+
+/**
+ * Mark every per-turn change record rooted at `target` (a matchKey) as
+ * unavailable: the record and its file list stay, so the turn's history card
+ * still says what changed, but each file drops its patch (the removed
+ * worktree's contents) and becomes non-revertable, so no Undo or Reapply is
+ * offered. Records of other roots are untouched. Serialized with every other
+ * change-record write of the session.
+ */
+async function forgetChangeRecordsRoot(target, removed, kept) {
+  let names = [];
+  try {
+    names = await readdir(changesRoot());
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (!name.endsWith('.json')) continue;
+    const path = join(changesRoot(), name);
+    let sessionId = '';
+    try {
+      sessionId = clean(JSON.parse(await readFile(path, 'utf8'))?.sessionId);
+    } catch {
+      // Unreadable or corrupt file: no session id, skipped below.
+    }
+    if (!sessionId || changesPath(sessionId) !== path) continue;
+    await chain(`changes:${sessionId}`, async () => {
+      const records = (await readChangesFile(sessionId))?.records;
+      if (!records) return;
+      const marked = [];
+      const next = records.map((record) => {
+        const files = Array.isArray(record?.files) ? record.files : [];
+        if (matchKey(record?.root) !== target || files.every(changeFileUnavailable)) return record;
+        marked.push(record.checkpointId);
+        return {
+          ...record,
+          files: files.map(unavailableChangeFile),
+          revision: (Number(record.revision) || 0) + 1,
+          updatedAt: Date.now(),
+        };
+      });
+      if (marked.length === 0) return;
+      try {
+        await writeChangeRecords(sessionId, next);
+        removed.push(...marked.map((checkpointId) => `${path}#${checkpointId}`));
+      } catch {
+        kept.push(path);
+      }
+    });
+  }
+}
+
+// ── Per-turn change records ─────────────────────────────────────────────────
+//
+// One file per session holding every retained turn's frozen net diff, keyed by
+// checkpointId (the outer prompt id). Unlike the baseline index above these
+// carry their own complete patches, so they need no shadow object to survive.
+
+const CHANGES_VERSION = 1;
+// Byte budget of one session's change records; the oldest turns go first.
+const MAX_CHANGE_BYTES_PER_SESSION = 32 * 1024 * 1024;
+const MAX_CHANGE_RECORD_FILES = 512;
+const CHANGE_RECORD_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+let changesSweepDone = false;
+
+function changesRoot() {
+  return join(recordRoot(), 'changes');
+}
+
+function changesPath(sessionId) {
+  const hash = createHash('sha256').update(sessionId).digest('hex').slice(0, 24);
+  return join(changesRoot(), `${hash}.json`);
+}
+
+async function readChangesFile(sessionId) {
+  try {
+    const parsed = JSON.parse(await readFile(changesPath(sessionId), 'utf8'));
+    if (parsed?.version !== CHANGES_VERSION || parsed.sessionId !== sessionId) return null;
+    return Array.isArray(parsed.records) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Evict the oldest turns until the session fits its byte budget; a turn that
+ *  alone exceeds it drops its largest patches (those files stop being
+ *  revertable) instead of the whole record. */
+function boundChangeRecords(records, keepCheckpointId) {
+  const sizes = records.map((record) => Buffer.byteLength(JSON.stringify(record), 'utf8'));
+  let total = sizes.reduce((sum, size) => sum + size, 0);
+  for (let index = 0; total > MAX_CHANGE_BYTES_PER_SESSION && index < records.length; ) {
+    if (records[index].checkpointId === keepCheckpointId) {
+      index += 1;
+      continue;
+    }
+    total -= sizes[index];
+    records.splice(index, 1);
+    sizes.splice(index, 1);
+  }
+  if (total <= MAX_CHANGE_BYTES_PER_SESSION) return;
+  const kept = records.find((record) => record.checkpointId === keepCheckpointId);
+  // Replay patches and display patches share one budget, measured in UTF-8 bytes.
+  const weight = (file) =>
+    ['patch', 'viewPatch'].reduce(
+      (sum, key) => sum + (typeof file[key] === 'string' ? Buffer.byteLength(file[key], 'utf8') : 0),
+      0
+    );
+  const largest = [...(kept?.files || []), ...(kept?.outside || [])]
+    .filter((file) => weight(file) > 0)
+    .sort((left, right) => weight(right) - weight(left));
+  for (const file of largest) {
+    if (total <= MAX_CHANGE_BYTES_PER_SESSION) break;
+    total -= weight(file);
+    file.patch = null;
+    delete file.patchEncoding;
+    delete file.viewPatch;
+    file.revertable = false;
+    file.reason = 'change is too large to keep for undo';
+    file.patchOmitted = true;
+  }
+}
+
+// Test seam: runs before every change-record write; a throw fails the write.
+let changeWriteHookForTest = null;
+
+async function writeChangeRecords(sessionId, records) {
+  await changeWriteHookForTest?.(sessionId, records);
+  changeRecordsCache.delete(sessionId);
+  await mkdir(changesRoot(), { recursive: true });
+  if (!changesSweepDone) {
+    changesSweepDone = true;
+    void sweepDirectory(changesRoot(), CHANGE_RECORD_TTL_MS, MAX_CHANGE_RECORD_FILES);
+  }
+  await writeJsonAtomically(changesPath(sessionId), { version: CHANGES_VERSION, sessionId, records });
+}
+
+const changeContent = (record) =>
+  JSON.stringify([record.kind, record.root, record.agents || [], record.files || [], record.outside || []]);
+
+/**
+ * Upsert one turn's frozen changes. Every file of the new freeze is `applied`;
+ * a file the user had already undone and that the new net diff no longer
+ * contains keeps its `reverted` entry, so Reapply survives a re-seal. The
+ * revision bumps only when the record actually changed. Resolves to the
+ * stored record.
+ */
+export async function upsertTurnChangeRecord(sessionId, next) {
+  const id = clean(sessionId);
+  const checkpointId = clean(next?.checkpointId);
+  if (!id || !checkpointId) return null;
+  return await chain(`changes:${id}`, async () => {
+    const records = (await readChangesFile(id))?.records || [];
+    const index = records.findIndex((record) => record?.checkpointId === checkpointId);
+    const prior = index >= 0 ? records[index] : null;
+    const files = (Array.isArray(next.files) ? next.files : []).map((file) => ({ ...file, state: 'applied' }));
+    const present = new Set(files.map((file) => rootKey(file.path)));
+    for (const file of prior?.files || []) {
+      if (file.state === 'reverted' && !present.has(rootKey(file.path))) files.push(file);
+    }
+    files.sort((left, right) => left.path.localeCompare(right.path));
+    const candidate = {
+      checkpointId,
+      kind: clean(next.kind) || 'git',
+      root: clean(next.root),
+      agents: Array.isArray(next.agents) ? next.agents : [],
+      files,
+      // View-only edits outside the root of a Git turn: never undone or
+      // replayed, listed only by the session review.
+      ...(Array.isArray(next.outside) && next.outside.length ? { outside: next.outside } : {}),
+    };
+    if (prior && changeContent(prior) === changeContent(candidate)) return prior;
+    const now = Date.now();
+    const record = {
+      ...candidate,
+      revision: (Number(prior?.revision) || 0) + 1,
+      createdAt: Number(prior?.createdAt) || now,
+      updatedAt: now,
+    };
+    if (index >= 0) records[index] = record;
+    else records.push(record);
+    boundChangeRecords(records, checkpointId);
+    await writeChangeRecords(id, records);
+    return records.find((entry) => entry.checkpointId === checkpointId) || null;
+  });
+}
+
+/** Apply `mutate(record)` (returning the next files, or null for no change)
+ *  and bump the revision. Serialized with every other write of the session. */
+export async function updateTurnChangeRecord(sessionId, checkpointId, mutate) {
+  const id = clean(sessionId);
+  const key = clean(checkpointId);
+  if (!id || !key) return null;
+  return await chain(`changes:${id}`, async () => {
+    const records = (await readChangesFile(id))?.records || [];
+    const index = records.findIndex((record) => record?.checkpointId === key);
+    if (index < 0) return null;
+    const files = mutate(records[index]);
+    if (!files) return records[index];
+    records[index] = {
+      ...records[index],
+      files,
+      revision: (Number(records[index].revision) || 0) + 1,
+      updatedAt: Date.now(),
+    };
+    await writeChangeRecords(id, records);
+    return records[index];
+  });
+}
+
+/** One turn's change record by its exact checkpoint id; never a fallback. */
+export async function loadTurnChangeRecord(sessionId, checkpointId) {
+  const id = clean(sessionId);
+  const key = clean(checkpointId);
+  if (!id || !key) return null;
+  const records = (await readChangesFile(id))?.records || [];
+  return records.find((record) => record?.checkpointId === key) || null;
+}
+
+// Parsed change records by session, valid while the file's mtime and size are
+// unchanged: the session review refreshes every few seconds and must not
+// re-read and re-parse a multi-megabyte file each time. Callers never mutate.
+const changeRecordsCache = new Map();
+const CHANGE_RECORDS_CACHE_SESSIONS = 8;
+
+/** Every retained turn's change record of a session, oldest first. */
+export async function loadTurnChangeRecords(sessionId) {
+  const id = clean(sessionId);
+  if (!id) return [];
+  let signature = '';
+  try {
+    const info = await stat(changesPath(id));
+    signature = `${info.mtimeMs}:${info.size}`;
+  } catch {
+    changeRecordsCache.delete(id);
+    return [];
+  }
+  const cached = changeRecordsCache.get(id);
+  if (cached?.signature === signature) return cached.records;
+  const records = ((await readChangesFile(id))?.records || [])
+    .filter(Boolean)
+    .sort((left, right) => (Number(left.createdAt) || 0) - (Number(right.createdAt) || 0));
+  changeRecordsCache.delete(id);
+  changeRecordsCache.set(id, { signature, records });
+  if (changeRecordsCache.size > CHANGE_RECORDS_CACHE_SESSIONS) {
+    changeRecordsCache.delete(changeRecordsCache.keys().next().value);
+  }
+  return records;
+}
+
+export function _setTurnChangeRecordWriteHookForTest(hook) {
+  changeWriteHookForTest = typeof hook === 'function' ? hook : null;
+}
+
 export function _setTurnSnapshotStoreRootForTest(directory) {
   recordRootOverride = clean(directory);
   writeChains.clear();
+  changeRecordsCache.clear();
   sweepDone = false;
+  changesSweepDone = false;
 }