create-walle 0.9.21 → 0.9.23

package/template/wall-e/coding/side-git-snapshot.js

@@ -6,6 +6,24 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 
+// Side-repo exclude defaults: applied even when the target worktree has no
+// .gitignore, so a stray `node_modules` never lands in a snapshot commit.
+const DEFAULT_EXCLUDES = [
+  'node_modules/',
+  '.git/',
+  'dist/',
+  'build/',
+  'coverage/',
+  '.next/',
+  '.cache/',
+  '.venv/',
+  '__pycache__/',
+  '*.log',
+  '.DS_Store',
+];
+
+const MAX_SNAPSHOT_FILE_BYTES = 2 * 1024 * 1024;
+
 class SideGitSnapshotStore {
   constructor({
     snapshotsDir = defaultSnapshotsDir(),
@@ -40,6 +58,125 @@ class SideGitSnapshotStore {
     };
   }
 
+  /**
+   * Snapshot the ENTIRE worktree into the side repo (one commit per step
+   * boundary). Respects the worktree's .gitignore plus DEFAULT_EXCLUDES,
+   * skips files over MAX_SNAPSHOT_FILE_BYTES, and reuses the previous
+   * commit when nothing changed (per-turn debounce).
+   */
+  captureWorktree({ cwd, sessionId = '', boundaryId = '', label = '' } = {}) {
+    const root = path.resolve(cwd || process.cwd());
+    const repo = this._repo(root);
+    this._ensureRepo(repo);
+
+    this._git(repo, ['add', '-A', '.']);
+    this._unstageLargeFiles(repo);
+
+    const head = this._headCommit(repo);
+    if (head && !this._hasStagedChanges(repo, head)) {
+      return {
+        kind: 'side_git_worktree',
+        repoDir: repo.repoDir,
+        gitDir: repo.gitDir,
+        cwd: root,
+        commit: head,
+        reused: true,
+        timestamp: this.now(),
+      };
+    }
+
+    this._git(repo, [
+      'commit',
+      '--allow-empty',
+      '-m',
+      `Wall-E worktree ${sessionId || 'session'} ${boundaryId || ''} ${label || ''}`.trim(),
+    ]);
+    return {
+      kind: 'side_git_worktree',
+      repoDir: repo.repoDir,
+      gitDir: repo.gitDir,
+      cwd: root,
+      commit: this._git(repo, ['rev-parse', 'HEAD']).trim(),
+      reused: false,
+      timestamp: this.now(),
+    };
+  }
+
+  /**
+   * Restore the worktree to a snapshot commit. Resets tracked files to the
+   * snapshot state; files created AFTER the snapshot (untracked in it) are
+   * left in place — deliberately, so a rewind never deletes user files the
+   * snapshot system has never seen.
+   */
+  restoreWorktree({ cwd, commit } = {}) {
+    if (!commit) throw new Error('commit is required');
+    const root = path.resolve(cwd || process.cwd());
+    const repo = this._repo(root);
+    if (!fs.existsSync(repo.gitDir)) throw new Error(`No side-git repo for ${root}`);
+    this._git(repo, ['reset', '--hard', commit]);
+    return {
+      kind: 'side_git_worktree',
+      commit,
+      cwd: root,
+      timestamp: this.now(),
+    };
+  }
+
+  /** Diff between two worktree snapshots (or a snapshot and HEAD). */
+  diffWorktree({ cwd, fromCommit, toCommit = 'HEAD' } = {}) {
+    if (!fromCommit) throw new Error('fromCommit is required');
+    const root = path.resolve(cwd || process.cwd());
+    const repo = this._repo(root);
+    if (!fs.existsSync(repo.gitDir)) throw new Error(`No side-git repo for ${root}`);
+    return this._git(repo, ['diff', '--stat', fromCommit, toCommit]);
+  }
+
+  /** Housekeeping: drop unreferenced snapshot objects older than `days`. */
+  prune({ cwd, days = 7 } = {}) {
+    const root = path.resolve(cwd || process.cwd());
+    const repo = this._repo(root);
+    if (!fs.existsSync(repo.gitDir)) return null;
+    this._git(repo, ['gc', `--prune=${days}.days`, '--quiet']);
+    return { pruned: true, repoDir: repo.repoDir };
+  }
+
+  _headCommit(repo) {
+    try {
+      return this._git(repo, ['rev-parse', 'HEAD']).trim();
+    } catch {
+      return null;
+    }
+  }
+
+  _hasStagedChanges(repo, headCommit) {
+    try {
+      this._git(repo, ['diff', '--cached', '--quiet', headCommit]);
+      return false;
+    } catch {
+      return true;
+    }
+  }
+
+  _unstageLargeFiles(repo) {
+    let staged;
+    try {
+      staged = this._git(repo, ['diff', '--cached', '--name-only', '-z']);
+    } catch {
+      return;
+    }
+    for (const rel of staged.split('\0')) {
+      if (!rel) continue;
+      try {
+        const abs = path.join(repo.cwd, rel);
+        if (fs.statSync(abs).size > MAX_SNAPSHOT_FILE_BYTES) {
+          this._git(repo, ['reset', '-q', '--', rel]);
+        }
+      } catch {
+        // deleted/unreadable — leave staged (deletions must be recorded)
+      }
+    }
+  }
+
   restore({ cwd, commit, files = [] } = {}) {
     if (!commit) throw new Error('commit is required');
     const root = path.resolve(cwd || process.cwd());
@@ -76,9 +213,20 @@ class SideGitSnapshotStore {
   }
 
   _ensureRepo(repo) {
-    if (fs.existsSync(repo.gitDir)) return;
-    fs.mkdirSync(repo.repoDir, { recursive: true });
-    execFileSync('git', ['init', repo.repoDir], { stdio: 'ignore' });
+    if (!fs.existsSync(repo.gitDir)) {
+      fs.mkdirSync(repo.repoDir, { recursive: true });
+      execFileSync('git', ['init', repo.repoDir], { stdio: 'ignore' });
+    }
+    const excludeFile = path.join(repo.gitDir, 'info', 'exclude');
+    try {
+      const current = fs.existsSync(excludeFile) ? fs.readFileSync(excludeFile, 'utf8') : '';
+      if (!current.includes('node_modules/')) {
+        fs.mkdirSync(path.dirname(excludeFile), { recursive: true });
+        fs.writeFileSync(excludeFile, `${current.trimEnd()}\n${DEFAULT_EXCLUDES.join('\n')}\n`);
+      }
+    } catch {
+      // exclude file is an optimization, not a requirement
+    }
   }
 
   _existsInCommit(repo, commit, relPath) {
@@ -97,7 +245,13 @@ class SideGitSnapshotStore {
       '-c', 'user.name=Wall-E',
       '-c', 'user.email=walle@example.invalid',
       ...args,
-    ], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    ], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      // Relative pathspecs ('.', 'src/a.js') resolve against the git
+      // process cwd, not --work-tree — run from the worktree root.
+      cwd: fs.existsSync(repo.cwd) ? repo.cwd : undefined,
+    });
   }
 }
 
@@ -126,4 +280,6 @@ module.exports = {
   SideGitSnapshotStore,
   defaultSnapshotsDir,
   relativePaths,
+  DEFAULT_EXCLUDES,
+  MAX_SNAPSHOT_FILE_BYTES,
 };

package/template/wall-e/coding/snapshot-service.js

@@ -6,13 +6,77 @@ const { newId } = require('./model-message');
 const { SideGitSnapshotStore } = require('./side-git-snapshot');
 
 const MUTATING_TOOLS = new Set(['write_file', 'edit_file', 'multi_edit', 'apply_patch']);
+const MAX_PERSISTED_BOUNDARIES = 50;
+const BOUNDARY_KV_PREFIX = 'coding:boundaries:';
+
+/**
+ * Persists snapshot boundary records to the brain KV store so rewind
+ * survives process restarts. Falls back to module memory when the brain
+ * is unavailable (tests, embedded contexts).
+ */
+const _memoryBoundaries = new Map();
+
+class BoundaryStore {
+  constructor({ brain = null } = {}) {
+    this.brain = brain;
+  }
+
+  save(record) {
+    if (!record?.sessionId || !record?.boundaryId) return;
+    const key = BOUNDARY_KV_PREFIX + record.sessionId;
+    const list = this.list(record.sessionId).filter((entry) => entry.boundaryId !== record.boundaryId);
+    list.push(record);
+    while (list.length > MAX_PERSISTED_BOUNDARIES) list.shift();
+    this._setKv(key, JSON.stringify(list));
+  }
+
+  list(sessionId) {
+    if (!sessionId) return [];
+    const raw = this._getKv(BOUNDARY_KV_PREFIX + sessionId);
+    if (!raw) return [];
+    try {
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+
+  get(sessionId, boundaryId) {
+    return this.list(sessionId).find((entry) => entry.boundaryId === boundaryId) || null;
+  }
+
+  _getKv(key) {
+    if (this.brain?.getKv) return this.brain.getKv(key);
+    try {
+      const brain = require('../brain');
+      if (brain?.getKv) return brain.getKv(key);
+    } catch {}
+    return _memoryBoundaries.get(key) || '';
+  }
+
+  _setKv(key, value) {
+    if (this.brain?.setKv) return this.brain.setKv(key, value);
+    try {
+      const brain = require('../brain');
+      if (brain?.setKv) return brain.setKv(key, value);
+    } catch {}
+    _memoryBoundaries.set(key, value);
+    return null;
+  }
+}
 
 class SnapshotService {
-  constructor({ cwd = process.cwd(), snapshot = null, sideGitSnapshot = null, now } = {}) {
+  // worktreeSnapshots and boundaryStore are deliberately opt-in: callers
+  // that want whole-worktree snapshots + persisted boundaries (the agent
+  // loop) pass them explicitly; embedded/test constructions stay cheap.
+  constructor({ cwd = process.cwd(), snapshot = null, sideGitSnapshot = null, boundaryStore = null, worktreeSnapshots = false, now } = {}) {
     this.cwd = path.resolve(cwd);
     this.snapshot = snapshot || new SnapshotManager(this.cwd);
     this.now = now || (() => new Date().toISOString());
     this.sideGitSnapshot = sideGitSnapshot === false ? null : (sideGitSnapshot || new SideGitSnapshotStore({ now: this.now }));
+    this.boundaryStore = boundaryStore || null;
+    this.worktreeSnapshots = Boolean(worktreeSnapshots);
     this.boundaries = new Map();
     this.activeBoundaryId = null;
   }
@@ -31,8 +95,27 @@ class SnapshotService {
       stackDepths: this.snapshot.getStackDepths ? this.snapshot.getStackDepths() : {},
       capturedFiles: [],
     };
+    // Whole-worktree snapshot per step: catches mutations the per-file path
+    // can't see (run_shell sed/codegen/formatters). Reuses the previous
+    // commit when nothing changed, so quiet turns cost one `git status`.
+    if (this.worktreeSnapshots && this.sideGitSnapshot?.captureWorktree) {
+      try {
+        const worktree = this.sideGitSnapshot.captureWorktree({
+          cwd: this.cwd,
+          sessionId,
+          boundaryId,
+          label: 'step_start',
+        });
+        if (worktree?.commit) {
+          record.worktree = { commit: worktree.commit, repoDir: worktree.repoDir, reused: Boolean(worktree.reused) };
+        }
+      } catch (err) {
+        record.worktree = { error: err.message };
+      }
+    }
     this.boundaries.set(boundaryId, record);
     this.activeBoundaryId = boundaryId;
+    this._persistBoundary(record);
     return publicBoundary(record);
   }
 
@@ -105,6 +188,21 @@ class SnapshotService {
   revertToBoundary(boundaryId = this.activeBoundaryId) {
     const boundary = this.boundaries.get(boundaryId);
     if (!boundary) throw new Error(`No snapshot boundary: ${boundaryId}`);
+    // Worktree snapshots restore everything (including shell mutations);
+    // the per-file stack only knows files Wall-E's own edit tools touched.
+    if (boundary.worktree?.commit && this.sideGitSnapshot?.restoreWorktree) {
+      const worktree = this.sideGitSnapshot.restoreWorktree({
+        cwd: boundary.cwd,
+        commit: boundary.worktree.commit,
+      });
+      return {
+        boundaryId,
+        restoredFiles: [],
+        worktree,
+        sideGit: null,
+        timestamp: this.now(),
+      };
+    }
     const restoredFiles = this.snapshot.restoreToStackDepths
       ? this.snapshot.restoreToStackDepths(boundary.stackDepths)
       : fallbackRestoreAll(this.snapshot);
@@ -122,6 +220,24 @@ class SnapshotService {
     return boundary ? publicBoundary(boundary) : null;
   }
 
+  _persistBoundary(record) {
+    if (!this.boundaryStore?.save || !record.sessionId) return;
+    try {
+      this.boundaryStore.save({
+        boundaryId: record.boundaryId,
+        snapshotId: record.snapshotId,
+        kind: record.kind,
+        sessionId: record.sessionId,
+        cwd: record.cwd,
+        messageId: record.messageId,
+        timestamp: record.timestamp,
+        worktree: record.worktree || null,
+      });
+    } catch (err) {
+      console.warn(`[snapshot] Failed to persist boundary ${record.boundaryId}: ${err.message}`);
+    }
+  }
+
   _captureSideGit({ sessionId, cwd, messageId, toolName, files }) {
     if (!this.sideGitSnapshot?.capture || !files.length) return null;
     try {
@@ -185,6 +301,7 @@ function publicBoundary(record) {
     timestamp: record.timestamp,
     capturedFiles: [...record.capturedFiles],
     sideGit: record.sideGit || null,
+    worktree: record.worktree || null,
   };
 }
 
@@ -193,9 +310,34 @@ function fallbackRestoreAll(snapshot) {
   return snapshot.files ? snapshot.files() : [];
 }
 
+/**
+ * Standalone rewind surface for API/UI callers (works after process
+ * restarts — boundaries come from the persisted store, restores go through
+ * the side-git repo keyed by cwd).
+ */
+function listSessionBoundaries(sessionId, { brain = null } = {}) {
+  return new BoundaryStore({ brain }).list(sessionId)
+    .map((record) => ({ ...record }))
+    .reverse(); // newest first
+}
+
+function revertSessionBoundary({ sessionId, boundaryId, brain = null, sideGitSnapshot = null } = {}) {
+  if (!sessionId || !boundaryId) throw new Error('sessionId and boundaryId are required');
+  const record = new BoundaryStore({ brain }).get(sessionId, boundaryId);
+  if (!record) throw new Error(`No persisted boundary ${boundaryId} for session ${sessionId}`);
+  if (!record.worktree?.commit) throw new Error(`Boundary ${boundaryId} has no worktree snapshot to restore`);
+  const store = sideGitSnapshot || new SideGitSnapshotStore();
+  const worktree = store.restoreWorktree({ cwd: record.cwd, commit: record.worktree.commit });
+  return { boundaryId, sessionId, cwd: record.cwd, worktree };
+}
+
 module.exports = {
   SnapshotService,
+  BoundaryStore,
+  listSessionBoundaries,
+  revertSessionBoundary,
   inferMutatingPaths,
   inferPatchPaths,
   MUTATING_TOOLS,
+  MAX_PERSISTED_BOUNDARIES,
 };