memoir-cli 3.0.1 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memoir-cli",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "description": "Sync AI memory across devices. Back up and restore Claude, Gemini, Codex, Cursor, Copilot, Windsurf configs. Snapshot coding sessions and resume on another machine. Migrate instructions between AI assistants.",
   "main": "src/index.js",
   "type": "module",

package/src/adapters/index.js

@@ -37,15 +37,22 @@ export const adapters = [
       if (src === claudeDir) return true;
       // Only allow these top-level dirs
       const topDir = rel.split(path.sep)[0];
-      const allowedDirs = ['projects', 'settings'];
       const allowedFiles = ['settings.json', 'settings.local.json'];
       // Allow specific top-level config files
       if (!rel.includes(path.sep) && allowedFiles.includes(basename)) return true;
       // Allow projects dir (contains memory .md files)
       if (topDir === 'projects') {
-        // Allow directory traversal
-        try { if (nodeFs.statSync(src).isDirectory()) return true; } catch {}
-        // Only sync memory markdown files
+        // Allow directory traversal but skip dirs that only contain session data
+        try {
+          if (nodeFs.statSync(src).isDirectory()) {
+            // Skip subagents and UUID-named session dirs (contain large .jsonl files, no .md)
+            if (basename === 'subagents') return false;
+            // UUID pattern: 8-4-4-4-12 hex chars
+            if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(basename)) return false;
+            return true;
+          }
+        } catch {}
+        // Only sync memory markdown files — skip .jsonl session files
         return basename.endsWith('.md');
       }
       // Allow settings dir

package/src/adapters/restore.js

@@ -170,6 +170,60 @@ async function mergeMemoryDirs(src, dest) {
   }
 }
 
+// After restore, ensure every memory .md file is referenced in its MEMORY.md index.
+// Without this, files synced from another machine exist but Claude won't know about them.
+async function reconcileMemoryIndexes(claudeSource) {
+  const projectsDir = path.join(claudeSource, 'projects');
+  if (!fs.existsSync(projectsDir)) return;
+
+  const entries = fs.readdirSync(projectsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const memDir = path.join(projectsDir, entry.name, 'memory');
+    if (!fs.existsSync(memDir)) continue;
+
+    const memoryMdPath = path.join(memDir, 'MEMORY.md');
+    let memoryMd = '';
+    if (fs.existsSync(memoryMdPath)) {
+      memoryMd = fs.readFileSync(memoryMdPath, 'utf8');
+    }
+
+    // Find all .md files in this memory dir
+    const mdFiles = fs.readdirSync(memDir)
+      .filter(f => f.endsWith('.md') && f !== 'MEMORY.md');
+
+    // Check which ones are NOT referenced in MEMORY.md
+    const unreferenced = mdFiles.filter(f => {
+      const name = f.replace('.md', '');
+      // Check for markdown link [text](file.md) or plain filename mention
+      return !memoryMd.includes(f) && !memoryMd.includes(`(${f})`);
+    });
+
+    if (unreferenced.length === 0) continue;
+
+    // Read each unreferenced file to get its name/description from frontmatter
+    let additions = '\n\n## Synced from another machine\n';
+    for (const file of unreferenced) {
+      const content = fs.readFileSync(path.join(memDir, file), 'utf8');
+      // Try to extract name from frontmatter
+      const nameMatch = content.match(/^name:\s*(.+)/m);
+      const descMatch = content.match(/^description:\s*(.+)/m);
+      const name = nameMatch ? nameMatch[1].trim() : file.replace('.md', '').replace(/-/g, ' ');
+      const desc = descMatch ? descMatch[1].trim() : '';
+      additions += `- [${name}](${file})${desc ? ' — ' + desc : ''}\n`;
+    }
+
+    // Append to MEMORY.md
+    if (!memoryMd) {
+      memoryMd = '# Project Memory\n';
+    }
+    // Remove old "Synced from another machine" section if it exists, then re-add
+    memoryMd = memoryMd.replace(/\n\n## Synced from another machine\n[\s\S]*$/, '');
+    memoryMd = memoryMd.trimEnd() + additions;
+    fs.writeFileSync(memoryMdPath, memoryMd);
+  }
+}
+
 async function syncFiles(src, dest, changes) {
   const entries = await fs.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
@@ -284,6 +338,13 @@ export async function restoreMemories(sourceDir, spinner, onlyFilter = null, aut
           await syncFiles(backupDir, adapter.source, changes);
         }
 
+        // After syncing, reconcile MEMORY.md files
+        // MEMORY.md is an INDEX — it must reference all memory files from both machines
+        // This MUST run after syncFiles so newly copied files are included
+        if (adapter.name === 'Claude CLI') {
+          await reconcileMemoryIndexes(adapter.source);
+        }
+
         // Show summary of changes
         spinner.stop();
         const totalChanged = changes.added.length + changes.updated.length;

package/src/commands/push.js

@@ -13,6 +13,7 @@ import { findClaudeSessions, parseSession, generateContextHandoff, shouldIgnoreP
 import { scanForSecrets, printSecurityReport } from '../security/scanner.js';
 import { encryptDirectory, createVerifyToken } from '../security/encryption.js';
 import { getRawConfig, saveConfig, migrateConfigToV2 } from '../config.js';
+import { scanWorkspace } from '../workspace/tracker.js';
 
 export async function pushCommand(options = {}) {
   const config = await getConfig(options.profile);
@@ -32,6 +33,8 @@ export async function pushCommand(options = {}) {
   const stagingDir = path.join(os.tmpdir(), `memoir-staging-${Date.now()}`);
   await fs.ensureDir(stagingDir);
 
+  let encryptedDir = null;
+
   try {
     // Profile-level tool filter (config.only) merged with CLI --only flag
     const onlyRaw = options.only || (config.only ? config.only.join(',') : null);
@@ -99,6 +102,15 @@ export async function pushCommand(options = {}) {
       // Context capture is best-effort — don't fail the push
     }
 
+    // Scan workspace for projects (git repos + unbacked projects)
+    let workspaceManifest = null;
+    spinner.text = chalk.gray('Scanning workspace...');
+    try {
+      workspaceManifest = await scanWorkspace(stagingDir, spinner);
+    } catch {
+      // Workspace scan is best-effort
+    }
+
     // Count what was found
     const found = [];
     for (const adapter of adapters) {
@@ -160,7 +172,7 @@ export async function pushCommand(options = {}) {
       }]);
       spinner.start(chalk.gray('Encrypting...'));
 
-      const encryptedDir = path.join(os.tmpdir(), `memoir-encrypted-${Date.now()}`);
+      encryptedDir = path.join(os.tmpdir(), `memoir-encrypted-${Date.now()}`);
       await fs.ensureDir(encryptedDir);
       await encryptDirectory(stagingDir, encryptedDir, passphrase);
 
@@ -218,9 +230,18 @@ export async function pushCommand(options = {}) {
         contextLine += chalk.yellow(`  🔒 ${sessionInfo.secretsRedacted} secret(s) auto-redacted`) + '\n';
       }
     }
+    let workspaceLine = '';
+    if (workspaceManifest && workspaceManifest.projects.length > 0) {
+      const gitCount = workspaceManifest.projects.filter(p => p.type === 'git' && p.gitRemote).length;
+      const bundleCount = workspaceManifest.projects.filter(p => p.bundleFile).length;
+      const parts = [];
+      if (gitCount > 0) parts.push(`${gitCount} git`);
+      if (bundleCount > 0) parts.push(`${bundleCount} bundled`);
+      workspaceLine = '\n' + chalk.green('  ✔ Workspace') + chalk.gray(` (${workspaceManifest.projects.length} projects — ${parts.join(', ')})`) + '\n';
+    }
     console.log('\n' + boxen(
       gradient.pastel('  Backed up!  ') + '\n\n' +
-      toolList + contextLine + '\n' +
+      toolList + contextLine + workspaceLine + '\n' +
       chalk.white(`${totalFiles} files from ${found.length} tool${found.length !== 1 ? 's' : ''}`) + '\n' +
       (encrypted ? chalk.green('  🔒 E2E encrypted') + '\n' : '') +
       chalk.gray(`→ ${dest}`) + '\n\n' +
@@ -232,13 +253,8 @@ export async function pushCommand(options = {}) {
   } finally {
     await fs.remove(stagingDir);
     // Clean up encrypted dir if it was created
-    if (true) {
-      const encDirs = await fs.readdir(os.tmpdir());
-      for (const d of encDirs) {
-        if (d.startsWith('memoir-encrypted-')) {
-          await fs.remove(path.join(os.tmpdir(), d)).catch(() => {});
-        }
-      }
+    if (encryptedDir) {
+      await fs.remove(encryptedDir).catch(() => {});
     }
   }
 }

package/src/commands/restore.js

@@ -10,6 +10,7 @@ import { getConfig } from '../config.js';
 import { fetchFromLocal, fetchFromGit } from '../providers/restore.js';
 import { decryptDirectory, verifyPassphrase } from '../security/encryption.js';
 import { detectLocalHomeKey } from '../adapters/restore.js';
+import { restoreWorkspace } from '../workspace/tracker.js';
 
 const home = os.homedir();
 
@@ -169,6 +170,39 @@ export async function restoreCommand(options = {}) {
       }
     }
 
+    // Restore workspace (clone git projects, unpack bundles)
+    let workspaceResults = null;
+    try {
+      spinner.start(chalk.gray('Checking workspace...'));
+      workspaceResults = await restoreWorkspace(stagingDir, spinner, autoYes);
+      spinner.stop();
+
+      if (workspaceResults) {
+        const { cloned, unpacked, patched, skipped } = workspaceResults;
+        if (cloned.length > 0 || unpacked.length > 0) {
+          console.log('\n' + chalk.cyan.bold('  📁 Workspace restored:'));
+          for (const p of cloned) {
+            console.log(chalk.green(`    ✔ ${p.name}`) + chalk.gray(` → ${p.path}`));
+          }
+          for (const p of unpacked) {
+            console.log(chalk.green(`    ✔ ${p.name}`) + chalk.gray(` → ${p.path} (unpacked)`));
+          }
+          if (patched.length > 0) {
+            for (const p of patched) {
+              console.log(chalk.yellow(`    ↻ ${p.name}`) + chalk.gray(` — uncommitted changes applied`));
+            }
+          }
+          const existingCount = skipped.filter(s => s.reason === 'exists').length;
+          if (existingCount > 0) {
+            console.log(chalk.gray(`    ⏭ ${existingCount} project(s) already on this machine`));
+          }
+          restored = true;
+        }
+      }
+    } catch {
+      // Workspace restore is best-effort
+    }
+
     if (restored) {
       let handoffMsg = '';
       if (handoffInjected && handoffInfo) {
@@ -178,10 +212,17 @@ export async function restoreCommand(options = {}) {
           (handoffInfo.duration ? '\n' + chalk.gray(`   Duration: ${handoffInfo.duration}`) : '') + '\n' +
           chalk.gray('   Your AI will pick up where you left off.');
       }
+      let workspaceMsg = '';
+      if (workspaceResults) {
+        const total = workspaceResults.cloned.length + workspaceResults.unpacked.length;
+        if (total > 0) {
+          workspaceMsg = '\n' + chalk.cyan(`📁 ${total} project(s) restored to this machine`);
+        }
+      }
       console.log(boxen(
         gradient.pastel('  Done!  ') + '\n\n' +
         chalk.white('Your AI tools have their memories back.') +
-        handoffMsg + '\n' +
+        handoffMsg + workspaceMsg + '\n' +
         chalk.gray(handoffInjected ? '' : 'Restart your AI tools to pick up the changes.'),
         { padding: 1, borderStyle: 'round', borderColor: 'green', dimBorder: true }
       ) + '\n');

package/src/context/capture.js

@@ -42,12 +42,18 @@ export function findClaudeSessions() {
  */
 export function parseSession(sessionPath, maxSizeMB = 10) {
   const stat = fs.statSync(sessionPath);
-  if (stat.size > maxSizeMB * 1024 * 1024) {
-    // For large files, only parse the last portion
-    const raw = fs.readFileSync(sessionPath, 'utf8');
-    const lines = raw.split('\n');
-    const lastLines = lines.slice(-500); // Last 500 lines
-    return parseLines(lastLines);
+  const TAIL_BYTES = 2 * 1024 * 1024; // Read last 2MB max
+
+  if (stat.size > TAIL_BYTES) {
+    // For large files, only read the tail to avoid loading 20MB+ into memory
+    const fd = fs.openSync(sessionPath, 'r');
+    const buf = Buffer.alloc(TAIL_BYTES);
+    fs.readSync(fd, buf, 0, TAIL_BYTES, stat.size - TAIL_BYTES);
+    fs.closeSync(fd);
+    const raw = buf.toString('utf8');
+    // Skip the first (partial) line since we likely cut mid-line
+    const lines = raw.split('\n').slice(1);
+    return parseLines(lines);
   }
 
   const raw = fs.readFileSync(sessionPath, 'utf8').trim();

package/src/workspace/tracker.js

@@ -0,0 +1,350 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { execFileSync } from 'child_process';
+
+const home = os.homedir();
+
+/**
+ * Scan home directory for git projects and build a workspace manifest.
+ * Tracks: git remote URL, branch, last commit, uncommitted changes (as patch).
+ * For non-git projects with AI configs, bundles them as tar.gz.
+ */
+export async function scanWorkspace(stagingDir, spinner, opts = {}) {
+  const maxDepth = opts.maxDepth || 3;
+  const maxBundleSize = opts.maxBundleSize || 50 * 1024 * 1024; // 50MB
+
+  const skipDirs = new Set([
+    'node_modules', '.git', '.next', '.vercel', 'dist', 'build',
+    '__pycache__', '.venv', 'venv', '.cache', '.npm', '.bun',
+    'Library', '.Trash', 'Applications', 'Pictures', 'Music',
+    'Movies', 'Public', 'Downloads', '.local', '.cargo', '.rustup',
+    '.docker', '.ssh', '.config', '.claude', '.gemini'
+  ]);
+
+  // Project markers — files that indicate "this is a project"
+  const projectMarkers = [
+    'package.json', 'Cargo.toml', 'go.mod', 'pyproject.toml',
+    'requirements.txt', 'Gemfile', 'pom.xml', 'build.gradle',
+    'Makefile', 'CMakeLists.txt', '.project', 'CLAUDE.md',
+    'GEMINI.md', 'AGENTS.md', 'README.md',
+    // Also detect dirs with .git or multiple content files
+    '.gitignore', 'index.html', 'main.py', 'app.py', 'index.js',
+  ];
+
+  // Also detect dirs with multiple markdown/code files as potential projects
+  const isContentProject = (entries) => {
+    const mdFiles = entries.filter(e => !e.isDirectory() && e.name.endsWith('.md'));
+    return mdFiles.length >= 2; // 2+ markdown files = likely a writing project
+  };
+
+  const projects = [];
+
+  const scanDir = async (dir, depth = 0) => {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch { return; }
+
+    // Check if this dir is a project
+    const hasMarker = entries.some(e => !e.isDirectory() && projectMarkers.includes(e.name));
+    const hasContent = isContentProject(entries);
+
+    if ((hasMarker || hasContent) && dir !== home) {
+      const info = await getProjectInfo(dir);
+      if (info) projects.push(info);
+      // Don't recurse into sub-projects deeper than this
+      return;
+    }
+
+    // Recurse into subdirectories
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.') && entry.name !== '.github') continue;
+      if (skipDirs.has(entry.name)) continue;
+      await scanDir(path.join(dir, entry.name), depth + 1);
+    }
+  };
+
+  if (spinner) spinner.text = 'Scanning workspace for projects...';
+  await scanDir(home);
+
+  // Build manifest
+  const manifest = {
+    version: 1,
+    machine: os.hostname(),
+    platform: process.platform,
+    home: home,
+    scannedAt: new Date().toISOString(),
+    projects: []
+  };
+
+  const bundleDir = path.join(stagingDir, 'workspace-bundles');
+
+  for (const proj of projects) {
+    const entry = {
+      name: proj.name,
+      relativePath: proj.relativePath,
+      originalPath: proj.path,
+      type: proj.hasGit ? 'git' : 'bundle',
+    };
+
+    if (proj.hasGit) {
+      entry.gitRemote = proj.gitRemote;
+      entry.branch = proj.branch;
+      entry.lastCommit = proj.lastCommit;
+      entry.lastCommitMessage = proj.lastCommitMessage;
+
+      // Save uncommitted changes as patch
+      if (proj.hasDirtyWork && proj.lastCommit) {
+        try {
+          const patchDir = path.join(stagingDir, 'workspace-patches');
+          await fs.ensureDir(patchDir);
+          const diff = execFileSync('git', ['diff', 'HEAD'], {
+            cwd: proj.path,
+            maxBuffer: 10 * 1024 * 1024,
+            timeout: 10000
+          }).toString();
+          if (diff.trim()) {
+            const patchFile = `${proj.name}.patch`;
+            await fs.writeFile(path.join(patchDir, patchFile), diff);
+            entry.patchFile = patchFile;
+          }
+        } catch {
+          // Patch capture is best-effort
+        }
+      }
+    } else {
+      // Bundle non-git project (if small enough)
+      const size = await getDirSize(proj.path);
+      if (size <= maxBundleSize) {
+        try {
+          await fs.ensureDir(bundleDir);
+          const bundleName = `${proj.name}.tar.gz`;
+          execFileSync('tar', [
+            'czf', path.join(bundleDir, bundleName),
+            '-C', path.dirname(proj.path),
+            '--exclude', 'node_modules',
+            '--exclude', '.git',
+            '--exclude', '__pycache__',
+            '--exclude', '.venv',
+            '--exclude', 'dist',
+            '--exclude', 'build',
+            proj.name
+          ], { stdio: 'ignore', timeout: 30000 });
+          entry.bundleFile = bundleName;
+          entry.bundleSize = (await fs.stat(path.join(bundleDir, bundleName))).size;
+        } catch {
+          // Bundle is best-effort
+          entry.bundleFailed = true;
+        }
+      } else {
+        entry.tooLarge = true;
+        entry.size = size;
+      }
+    }
+
+    manifest.projects.push(entry);
+  }
+
+  // Save manifest
+  await fs.writeFile(
+    path.join(stagingDir, 'workspace.json'),
+    JSON.stringify(manifest, null, 2)
+  );
+
+  return manifest;
+}
+
+/**
+ * Restore workspace on this machine from a manifest.
+ * Clones git projects, unpacks bundles, applies patches.
+ */
+export async function restoreWorkspace(sourceDir, spinner, autoYes = false) {
+  const manifestPath = path.join(sourceDir, 'workspace.json');
+  if (!await fs.pathExists(manifestPath)) return null;
+
+  const manifest = await fs.readJson(manifestPath);
+  if (!manifest.projects || manifest.projects.length === 0) return null;
+
+  const results = { cloned: [], unpacked: [], patched: [], skipped: [] };
+
+  for (const proj of manifest.projects) {
+    // Determine where to put this project on the local machine
+    const localPath = resolveLocalPath(proj);
+
+    // Skip if project already exists locally
+    if (await fs.pathExists(localPath)) {
+      // But check if we should apply a patch
+      if (proj.patchFile) {
+        const patchPath = path.join(sourceDir, 'workspace-patches', proj.patchFile);
+        if (await fs.pathExists(patchPath)) {
+          try {
+            execFileSync('git', ['apply', '--check', patchPath], {
+              cwd: localPath, stdio: 'ignore'
+            });
+            execFileSync('git', ['apply', patchPath], {
+              cwd: localPath, stdio: 'ignore'
+            });
+            results.patched.push({ name: proj.name, path: localPath });
+          } catch {
+            // Patch didn't apply cleanly — skip
+          }
+        }
+      }
+      results.skipped.push({ name: proj.name, path: localPath, reason: 'exists' });
+      continue;
+    }
+
+    if (proj.type === 'git' && proj.gitRemote) {
+      // Clone the repo
+      if (spinner) spinner.text = `Cloning ${proj.name}...`;
+      try {
+        await fs.ensureDir(path.dirname(localPath));
+        execFileSync('git', ['clone', proj.gitRemote, localPath], {
+          stdio: 'ignore',
+          timeout: 120000
+        });
+
+        // Checkout the right branch
+        if (proj.branch && proj.branch !== 'main' && proj.branch !== 'master') {
+          try {
+            execFileSync('git', ['checkout', proj.branch], {
+              cwd: localPath, stdio: 'ignore'
+            });
+          } catch {}
+        }
+
+        // Apply patch if available
+        if (proj.patchFile) {
+          const patchPath = path.join(sourceDir, 'workspace-patches', proj.patchFile);
+          if (await fs.pathExists(patchPath)) {
+            try {
+              execFileSync('git', ['apply', patchPath], {
+                cwd: localPath, stdio: 'ignore'
+              });
+              results.patched.push({ name: proj.name, path: localPath });
+            } catch {}
+          }
+        }
+
+        results.cloned.push({ name: proj.name, path: localPath, remote: proj.gitRemote });
+      } catch (err) {
+        results.skipped.push({ name: proj.name, reason: `clone failed: ${err.message}` });
+      }
+    } else if (proj.bundleFile) {
+      // Unpack bundle
+      const bundlePath = path.join(sourceDir, 'workspace-bundles', proj.bundleFile);
+      if (await fs.pathExists(bundlePath)) {
+        if (spinner) spinner.text = `Unpacking ${proj.name}...`;
+        try {
+          await fs.ensureDir(path.dirname(localPath));
+          execFileSync('tar', ['xzf', bundlePath, '-C', path.dirname(localPath)], {
+            stdio: 'ignore',
+            timeout: 60000
+          });
+          results.unpacked.push({ name: proj.name, path: localPath });
+        } catch (err) {
+          results.skipped.push({ name: proj.name, reason: `unpack failed: ${err.message}` });
+        }
+      }
+    } else {
+      results.skipped.push({ name: proj.name, reason: proj.tooLarge ? 'too large' : 'no source' });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Figure out where a project should live on this machine.
+ */
+function resolveLocalPath(proj) {
+  // If the project had a relative path from home, use that
+  if (proj.relativePath) {
+    return path.join(home, proj.relativePath);
+  }
+  // Default: put it in home directory
+  return path.join(home, proj.name);
+}
+
+/**
+ * Get info about a project directory.
+ */
+async function getProjectInfo(dir) {
+  const name = path.basename(dir);
+  const relativePath = path.relative(home, dir);
+  const info = {
+    name,
+    path: dir,
+    relativePath,
+    hasGit: false,
+    gitRemote: null,
+    branch: null,
+    lastCommit: null,
+    lastCommitMessage: null,
+    hasDirtyWork: false,
+  };
+
+  // Check for git
+  const gitDir = path.join(dir, '.git');
+  if (await fs.pathExists(gitDir)) {
+    info.hasGit = true;
+    try {
+      const remote = execFileSync('git', ['remote', 'get-url', 'origin'], {
+        cwd: dir, stdio: ['pipe', 'pipe', 'ignore']
+      }).toString().trim();
+      info.gitRemote = remote;
+    } catch {}
+
+    try {
+      info.branch = execFileSync('git', ['branch', '--show-current'], {
+        cwd: dir, stdio: ['pipe', 'pipe', 'ignore']
+      }).toString().trim();
+    } catch {}
+
+    try {
+      info.lastCommit = execFileSync('git', ['log', '-1', '--format=%H'], {
+        cwd: dir, stdio: ['pipe', 'pipe', 'ignore']
+      }).toString().trim();
+      info.lastCommitMessage = execFileSync('git', ['log', '-1', '--format=%s'], {
+        cwd: dir, stdio: ['pipe', 'pipe', 'ignore']
+      }).toString().trim();
+    } catch {}
+
+    try {
+      const status = execFileSync('git', ['status', '--porcelain'], {
+        cwd: dir, stdio: ['pipe', 'pipe', 'ignore'], timeout: 5000
+      }).toString().trim();
+      info.hasDirtyWork = status.length > 0;
+    } catch {}
+  }
+
+  return info;
+}
+
+/**
+ * Get total size of a directory (excluding common heavy dirs).
+ */
+async function getDirSize(dir) {
+  let size = 0;
+  const skip = new Set(['node_modules', '.git', '__pycache__', '.venv', 'dist', 'build']);
+
+  const walk = async (d) => {
+    let entries;
+    try { entries = await fs.readdir(d, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (!skip.has(e.name)) await walk(path.join(d, e.name));
+      } else {
+        try {
+          const stat = await fs.stat(path.join(d, e.name));
+          size += stat.size;
+        } catch {}
+      }
+    }
+  };
+  await walk(dir);
+  return size;
+}