mixdog 1.2.2 → 1.2.4

package/src/runtime/shared/turn-review-reply.mjs

@@ -3,35 +3,9 @@
 // unchanged review answers with its tag instead of being sent again.
 import { createHash } from 'node:crypto';
 
-/** Per-file line counts of a unified diff, shaped like a Git snapshot's
- *  files (the turn review bar renders either the same way). */
-function filesFromPatch(patch) {
-  const files = [];
-  let current = null;
-  for (const line of String(patch || '').split('\n')) {
-    const header = /^diff --git a\/(.+?) b\/(.+)$/.exec(line);
-    if (header) {
-      current = {
-        path: header[2],
-        oldPath: header[1] === header[2] ? null : header[1],
-        status: 'M',
-        additions: 0,
-        deletions: 0,
-        binary: false,
-      };
-      files.push(current);
-      continue;
-    }
-    if (!current) continue;
-    if (line.startsWith('new file mode')) current.status = 'A';
-    else if (line.startsWith('deleted file mode')) current.status = 'D';
-    else if (line.startsWith('rename from')) current.status = 'R';
-    else if (line.startsWith('Binary files')) current.binary = true;
-    else if (line.startsWith('+') && !line.startsWith('+++')) current.additions += 1;
-    else if (line.startsWith('-') && !line.startsWith('---')) current.deletions += 1;
-  }
-  return files;
-}
+// Every review kind carries its files with their counts (summed own-write
+// deltas), so a collapsed bar never needs the patch text.
+const SUMMARY_KINDS = new Set(['worktree', 'scoped', 'tool']);
 
 /** `readReview(options)` answers the review itself. `summary` reaches it too,
  *  so a review rebuilt from its record never generates the patch it would
@@ -46,20 +20,15 @@ export async function turnReviewReply(readReview, options = {}) {
   };
   // Already a reply (a session runtime answers through this too): keep its tag.
   if (typeof review.etag === 'string') return known === review.etag ? { unchanged: true, etag: review.etag } : review;
-  // A collapsed bar shows files and line counts only. A Git-backed review
-  // carries those per file, so its patch text (tens of KB mid-turn) is
-  // left out until the bar is opened; other kinds count from the patch.
-  if (summary && (review.snapshotKind === 'worktree' || review.snapshotKind === 'scoped') && review.patch) {
+  // A collapsed bar shows files and line counts only, so the patch text
+  // (tens of KB mid-turn) is left out until the bar is opened.
+  if (summary && SUMMARY_KINDS.has(review.snapshotKind) && review.patch) {
     review = { ...review, patch: '', patchOmitted: true };
-  } else if (summary && review.snapshotKind === 'tool' && review.patch && !review.files?.length) {
-    // A contended worktree (several sessions on one repo) reviews this
-    // session's own tool edits and counts lines from the patch; the counts
-    // travel as files instead.
-    review = { ...review, files: filesFromPatch(review.patch), patch: '', patchOmitted: true };
   }
   // The review bar re-reads every few seconds during a turn; an unchanged
   // review answers with its tag instead of re-sending every patch. The tag
-  // covers what is sent, so a summary and a full review never share one.
+  // covers everything sent (`historyTurns` included), so a summary and a full
+  // review never share one.
   const etag = createHash('sha256').update(JSON.stringify(review)).digest('hex').slice(0, 32);
   return known === etag ? { unchanged: true, etag } : { ...review, etag };
 }

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

@@ -15,7 +15,6 @@
 import { createHash } from 'node:crypto';
 import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
-import { withFileLock } from './atomic-file.mjs';
 import { cleanString as clean } from './clean.mjs';
 import { resolvePluginData } from './plugin-paths.mjs';
 
@@ -265,106 +264,12 @@ export async function loadTurnSnapshotRecord(sessionId) {
   return null;
 }
 
-// ── Last computed review summary ────────────────────────────────────────────
-//
-// Rebuilding a recorded review rescans the whole worktree behind every other
-// capture of that repository. Entering a session reads the last computed
-// files and counts instead and lets the refreshing read follow. Keyed to the
-// turn record it was computed from, so a newer turn never shows an older one.
-
-let summarySweepDone = false;
-
-function summariesRoot() {
-  return join(recordRoot(), 'review-summaries');
-}
-
-/** Identity of the paths a record turn scopes its review to. */
-function summaryToolFilesKey(turn) {
-  return (Array.isArray(turn?.toolFiles) ? turn.toolFiles : []).map(rootKey).sort().join('\0');
-}
-
-function summaryPath(sessionId) {
+/** The review summary an earlier version cached per session (files and
+ *  counts of its last recorded review). Nothing writes it any more; deleting
+ *  a session's history still removes one left behind. */
+function legacySummaryPath(sessionId) {
   const hash = createHash('sha256').update(sessionId).digest('hex').slice(0, 24);
-  return join(summariesRoot(), `${hash}.json`);
-}
-
-// Test hook: runs inside the summary critical section, between the cleared
-// check and the write.
-let summaryWriteHookForTest = null;
-export function _setSummaryWriteHookForTest(hook) {
-  summaryWriteHookForTest = typeof hook === 'function' ? hook : null;
-}
-
-const SUMMARY_LOCK_TIMEOUT_MS = 10_000;
-const withSummaryLock = (sessionId, task) =>
-  withFileLock(`${summaryPath(sessionId)}.lock`, task, { timeoutMs: SUMMARY_LOCK_TIMEOUT_MS });
-
-// Summary saves still running. Callers fire them and move on, so a test that
-// removes the store root settles them first instead of racing their writes.
-const pendingSummarySaves = new Set();
-export async function _settleSummarySavesForTest() {
-  while (pendingSummarySaves.size) await Promise.allSettled([...pendingSummarySaves]);
-}
-
-/** Keep the files and counts last computed for `turn` (a loaded record turn). */
-export function saveTurnReviewSummary(sessionId, turn, review) {
-  const saving = saveTurnReviewSummaryNow(sessionId, turn, review);
-  pendingSummarySaves.add(saving);
-  const done = () => pendingSummarySaves.delete(saving);
-  saving.then(done, done);
-  return saving;
-}
-
-async function saveTurnReviewSummaryNow(sessionId, turn, review) {
-  const id = clean(sessionId);
-  if (!id || !turn?.baselineTree || !Array.isArray(review?.files)) return false;
-  return await chain(`summary:${id}`, async () => {
-    try {
-      await mkdir(summariesRoot(), { recursive: true });
-      if (!summarySweepDone) {
-        summarySweepDone = true;
-        void sweepDirectory(summariesRoot(), RECORD_TTL_MS, MAX_RECORD_FILES);
-      }
-      return await withSummaryLock(id, async () => {
-        // Deleted history stays deleted: a summary computed before the delete
-        // must not bring it back (a newly recorded turn ends the marker). The
-        // check and the write are one step against a delete in any process.
-        if (await sessionChangeHistoryCleared(id)) return false;
-        await summaryWriteHookForTest?.(id);
-        await writeJsonAtomically(summaryPath(id), {
-          version: RECORD_VERSION,
-          sessionId: id,
-          generation: Number(turn.generation) || 0,
-          baselineTree: clean(turn.baselineTree),
-          checkpointId: clean(turn.checkpointId),
-          toolFilesKey: summaryToolFilesKey(turn),
-          files: review.files,
-          patchTruncated: review.patchTruncated === true,
-          savedAt: Date.now(),
-        });
-        return true;
-      });
-    } catch {
-      return false;
-    }
-  });
-}
-
-/** The summary saved for exactly this record turn, else null. */
-export async function loadTurnReviewSummary(sessionId, turn) {
-  const id = clean(sessionId);
-  if (!id || !turn?.baselineTree) return null;
-  try {
-    const parsed = JSON.parse(await readFile(summaryPath(id), 'utf8'));
-    if (parsed?.version !== RECORD_VERSION || parsed.sessionId !== id || !Array.isArray(parsed.files)) return null;
-    if (parsed.baselineTree !== clean(turn.baselineTree)) return null;
-    if (parsed.generation !== (Number(turn.generation) || 0)) return null;
-    if (parsed.checkpointId !== clean(turn.checkpointId)) return null;
-    if (parsed.toolFilesKey !== summaryToolFilesKey(turn)) return null;
-    return parsed;
-  } catch {
-    return null;
-  }
+  return join(recordRoot(), 'review-summaries', `${hash}.json`);
 }
 
 /** Earliest retained baseline plus every path attributed to this session,
@@ -394,13 +299,8 @@ export async function clearSessionChangeHistory(sessionId) {
     // The marker lands before the records go: a failure in between leaves
     // the session answering empty, never resurrecting what was asked gone.
     await mkdir(clearedRoot(), { recursive: true });
-    // Under the summary's file lock, shared with every process: a summary
-    // write that passed its marker check finishes before the marker lands (and
-    // is removed with it); one that starts later sees the marker and stays away.
-    await withSummaryLock(id, async () => {
-      await writeJsonAtomically(clearedPath(id), { version: RECORD_VERSION, sessionId: id, clearedAt: Date.now() });
-      await rm(summaryPath(id), { force: true });
-    });
+    await writeJsonAtomically(clearedPath(id), { version: RECORD_VERSION, sessionId: id, clearedAt: Date.now() });
+    await rm(legacySummaryPath(id), { force: true });
     await rm(recordPath(id), { force: true });
   });
   return await chain(`changes:${id}`, async () => {
@@ -654,7 +554,14 @@ async function writeChangeRecords(sessionId, records) {
 }
 
 const changeContent = (record) =>
-  JSON.stringify([record.kind, record.root, record.agents || [], record.files || [], record.outside || []]);
+  JSON.stringify([
+    record.kind,
+    record.root,
+    record.counts || '',
+    record.agents || [],
+    record.files || [],
+    record.outside || [],
+  ]);
 
 /**
  * Upsert one turn's frozen changes. Every file of the new freeze is `applied`;
@@ -682,6 +589,10 @@ export async function upsertTurnChangeRecord(sessionId, next) {
       kind: clean(next.kind) || 'git',
       root: clean(next.root),
       agents: Array.isArray(next.agents) ? next.agents : [],
+      // `own`: each file's patch is the session's own tool writes (first
+      // before → last after, raw bytes) and its counts their summed deltas;
+      // an older record without it holds the net worktree diff and counts.
+      ...(clean(next.counts) ? { counts: clean(next.counts) } : {}),
       files,
       // View-only edits outside the root of a Git turn: never undone or
       // replayed, listed only by the session review.