claude-setup 1.1.5 → 1.1.7

package/dist/snapshot.js

@@ -12,8 +12,8 @@
  *
  * Zero API calls. All local filesystem operations.
  */
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
-import { join, dirname } from "path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlinkSync, statSync } from "fs";
+import { join, dirname, extname } from "path";
 import { createHash } from "crypto";
 const SNAPSHOTS_DIR = ".claude/snapshots";
 const TIMELINE_FILE = "timeline.json";
@@ -85,21 +85,35 @@ export function createSnapshot(cwd, command, changedFiles, opts = {}) {
         ...(opts.input ? { input: opts.input } : {}),
         changedFiles: changedFiles.map(f => f.path),
         summary: opts.summary ?? `${changedFiles.length} file(s) captured`,
+        fullSnapshot: true,
     };
     timeline.nodes.push(node);
+    delete timeline.restoredTo; // User is at latest — clear any restore marker
     writeTimeline(cwd, timeline);
     writeNodeData(cwd, nodeId, data);
     return node;
 }
 /**
- * Build the cumulative file state at a given node by accumulating
- * all files from node 0 through the target node. Later nodes override
- * earlier ones (last-write-wins), giving the full state at that point.
+ * Build the complete file state at a given node.
+ *
+ * Full snapshots (fullSnapshot: true) store the entire project state — used directly.
+ * Legacy delta snapshots accumulate from node 0 to target (last-write-wins).
+ *
+ * Why the distinction matters: with delta snapshots, if a file was deleted between A→B,
+ * it would wrongly appear in cumulative state at B (still present from A). Full snapshots
+ * avoid this because the target node's data IS the complete truth at that point.
  */
 export function buildCumulativeState(cwd, nodeId, timeline) {
     const targetIndex = timeline.nodes.findIndex(n => n.id === nodeId);
     if (targetIndex < 0)
         return null;
+    const targetNode = timeline.nodes[targetIndex];
+    // Full snapshot: the node's own data is already the complete project state
+    if (targetNode.fullSnapshot) {
+        const data = readNodeData(cwd, nodeId);
+        return data ? { ...data.files } : null;
+    }
+    // Legacy delta snapshot: accumulate from beginning to target
     const cumulative = {};
     for (let i = 0; i <= targetIndex; i++) {
         const data = readNodeData(cwd, timeline.nodes[i].id);
@@ -119,12 +133,11 @@ export function buildCumulativeState(cwd, nodeId, timeline) {
  * Does NOT delete other nodes — all nodes are preserved (like git).
  */
 export function restoreSnapshot(cwd, nodeId, timeline) {
-    // If no timeline provided, read it
     const tl = timeline ?? readTimeline(cwd);
-    // Build cumulative state up to this node
     const cumulativeFiles = buildCumulativeState(cwd, nodeId, tl);
     if (!cumulativeFiles)
-        return { restored: [], failed: [nodeId], stale: [] };
+        return { restored: [], failed: [nodeId], deleted: [], stale: [] };
+    // Step 1: Write all snapshot files to disk
     const restored = [];
     const failed = [];
     for (const [filePath, content] of Object.entries(cumulativeFiles)) {
@@ -140,29 +153,28 @@ export function restoreSnapshot(cwd, nodeId, timeline) {
             failed.push(filePath);
         }
     }
-    // Detect files that exist now but weren't in the cumulative state
-    // These are files added in later snapshots that may be stale
+    // Step 2: Scan the project NOW (using the just-restored .gitignore)
+    // and delete any file that isn't part of the snapshot.
+    // This makes restore a true time machine — the directory looks exactly
+    // like it did at this snapshot.
+    const rules = loadGitignoreRules(cwd); // uses restored .gitignore if it was snapshotted
+    const currentFiles = [];
+    scanProject(cwd, "", rules, currentFiles);
+    const deleted = [];
     const stale = [];
-    const targetIndex = tl.nodes.findIndex(n => n.id === nodeId);
-    if (targetIndex >= 0) {
-        const laterNodes = tl.nodes.slice(targetIndex + 1);
-        const allLaterFiles = new Set();
-        for (const node of laterNodes) {
-            const nodeData = readNodeData(cwd, node.id);
-            if (nodeData) {
-                for (const fp of Object.keys(nodeData.files)) {
-                    allLaterFiles.add(fp);
-                }
-            }
+    for (const f of currentFiles) {
+        if (cumulativeFiles[f.path])
+            continue; // in snapshot — already restored
+        // Not in snapshot → delete
+        try {
+            unlinkSync(join(cwd, f.path));
+            deleted.push(f.path);
         }
-        // Files in later snapshots but NOT in cumulative state at target
-        for (const filePath of allLaterFiles) {
-            if (!cumulativeFiles[filePath] && existsSync(join(cwd, filePath))) {
-                stale.push(filePath);
-            }
+        catch {
+            stale.push(f.path); // couldn't delete (permissions etc.)
         }
     }
-    return { restored, failed, stale };
+    return { restored, failed, deleted, stale };
 }
 /**
  * Record the last restored node in the timeline (for display purposes).
@@ -211,40 +223,164 @@ export function compareSnapshots(cwd, nodeIdA, nodeIdB) {
     }
     return { onlyInA, onlyInB, changed, identical };
 }
-/**
- * Collect current file contents for snapshot.
- * Reads tracked files + CLI-managed files from disk.
- */
-export function collectFilesForSnapshot(cwd, trackedPaths) {
-    const files = [];
-    const seen = new Set();
-    for (const filePath of trackedPaths) {
-        if (filePath === "__digest__" || filePath === ".env")
-            continue;
-        if (seen.has(filePath))
-            continue;
-        const fullPath = join(cwd, filePath);
-        if (!existsSync(fullPath))
-            continue;
-        try {
-            files.push({ path: filePath, content: readFileSync(fullPath, "utf8") });
-            seen.add(filePath);
+// ── Full-project file scanner (git-like coverage) ──────────────────────
+const MAX_FILE_BYTES = 1024 * 1024; // 1 MB per file
+/** Directory names always excluded (regardless of location in tree) */
+const EXCLUDE_DIRS = new Set([
+    ".git", "node_modules",
+    "dist", "build", "out", ".next", ".nuxt", ".svelte-kit", ".remix",
+    "__pycache__", "target", ".gradle", ".mvn", "vendor",
+    "coverage", ".nyc_output", ".c8",
+    ".cache", ".parcel-cache", ".turbo", ".vercel", ".netlify",
+    "tmp", "temp", ".tmp",
+]);
+/** Relative paths always excluded */
+const EXCLUDE_REL = new Set([
+    ".claude/snapshots",
+    ".claude/token-usage.json",
+    ".claude/claude-setup.json",
+]);
+/** Filenames always excluded (sensitive or OS noise) */
+const EXCLUDE_NAMES = new Set([
+    ".env", ".DS_Store", "Thumbs.db", "desktop.ini",
+]);
+/** Binary file extensions — skip */
+const BINARY_EXT = new Set([
+    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".tiff", ".ico", ".avif",
+    ".pdf",
+    ".zip", ".tar", ".gz", ".bz2", ".7z", ".rar", ".xz",
+    ".exe", ".dll", ".so", ".dylib", ".bin",
+    ".wasm",
+    ".woff", ".woff2", ".ttf", ".otf", ".eot",
+    ".mp3", ".mp4", ".wav", ".ogg", ".flac", ".avi", ".mov", ".mkv",
+    ".class", ".jar", ".war",
+    ".pyc", ".pyo", ".pyd",
+    ".o", ".a", ".lib",
+    ".db", ".sqlite", ".sqlite3",
+]);
+function parseGitignoreLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+        return null;
+    let pattern = trimmed;
+    const negated = pattern.startsWith("!");
+    if (negated)
+        pattern = pattern.slice(1);
+    const anchored = pattern.startsWith("/");
+    if (anchored)
+        pattern = pattern.slice(1);
+    const dirOnly = pattern.endsWith("/");
+    if (dirOnly)
+        pattern = pattern.slice(0, -1);
+    // Convert glob to regex
+    let regexStr = "";
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === "*" && pattern[i + 1] === "*") {
+            if (pattern[i + 2] === "/") {
+                regexStr += "(?:.+/)?";
+                i += 2;
+            }
+            else {
+                regexStr += ".*";
+                i++;
+            }
+        }
+        else if (ch === "*") {
+            regexStr += "[^/]*";
+        }
+        else if (ch === "?") {
+            regexStr += "[^/]";
+        }
+        else if (".+^${}()|[]\\".includes(ch)) {
+            regexStr += "\\" + ch;
+        }
+        else {
+            regexStr += ch;
         }
-        catch { /* skip unreadable */ }
     }
-    // Also capture CLI-managed files if not already included
-    const managed = ["CLAUDE.md", ".mcp.json", ".claude/settings.json"];
-    for (const m of managed) {
-        if (seen.has(m))
-            continue;
-        const fullPath = join(cwd, m);
-        if (!existsSync(fullPath))
+    const full = (anchored || pattern.includes("/"))
+        ? `^${regexStr}(?:/.*)?$`
+        : `(?:^|/)${regexStr}(?:/.*)?$`;
+    try {
+        return { negated, dirOnly, regex: new RegExp(full) };
+    }
+    catch {
+        return null;
+    }
+}
+function loadGitignoreRules(cwd) {
+    try {
+        return readFileSync(join(cwd, ".gitignore"), "utf8")
+            .split("\n").map(parseGitignoreLine)
+            .filter((r) => r !== null);
+    }
+    catch {
+        return [];
+    }
+}
+function matchesAnyRule(relPath, isDir, rules) {
+    let excluded = false;
+    for (const rule of rules) {
+        if (rule.dirOnly && !isDir)
             continue;
-        try {
-            files.push({ path: m, content: readFileSync(fullPath, "utf8") });
-            seen.add(m);
+        if (rule.regex.test(relPath))
+            excluded = !rule.negated;
+    }
+    return excluded;
+}
+function tryReadText(absPath) {
+    try {
+        const st = statSync(absPath);
+        if (!st.isFile() || st.size > MAX_FILE_BYTES)
+            return null;
+        const content = readFileSync(absPath, "utf8");
+        if (content.includes("\0"))
+            return null; // binary
+        return content;
+    }
+    catch {
+        return null;
+    }
+}
+function scanProject(cwd, relBase, rules, out) {
+    const abs = relBase ? join(cwd, relBase) : cwd;
+    try {
+        for (const entry of readdirSync(abs, { withFileTypes: true })) {
+            const relPath = relBase ? `${relBase}/${entry.name}` : entry.name;
+            const isDir = entry.isDirectory();
+            // Hard excludes
+            if (isDir && EXCLUDE_DIRS.has(entry.name))
+                continue;
+            if (EXCLUDE_REL.has(relPath) || relPath.startsWith(".claude/snapshots/"))
+                continue;
+            if (!isDir && EXCLUDE_NAMES.has(entry.name))
+                continue;
+            if (!isDir && BINARY_EXT.has(extname(entry.name).toLowerCase()))
+                continue;
+            // Gitignore
+            if (matchesAnyRule(relPath, isDir, rules))
+                continue;
+            if (isDir) {
+                scanProject(cwd, relPath, rules, out);
+            }
+            else {
+                const content = tryReadText(join(cwd, relPath));
+                if (content !== null)
+                    out.push({ path: relPath, content });
+            }
         }
-        catch { /* skip */ }
     }
-    return files;
+    catch { /* skip unreadable */ }
+}
+/**
+ * Collect ALL project files for snapshot — full git-like coverage.
+ * Respects .gitignore + hard exclusions (node_modules, .git, binaries, .env).
+ * The trackedPaths param is kept for API compat but ignored.
+ */
+export function collectFilesForSnapshot(cwd, _trackedPaths) {
+    const rules = loadGitignoreRules(cwd);
+    const out = [];
+    scanProject(cwd, "", rules, out);
+    return out;
 }

package/dist/tokens.js

@@ -292,8 +292,8 @@ export function readProjectSessions(projectCwd) {
         // Encode the CWD the way Claude Code does, then exact-match against project dirs.
         // This is the only reliable cross-platform approach — decoding is lossy when
         // folder names contain hyphens (e.g. "Claude-code-documentation").
-        //   Windows: C:\Users\ok\Desktop\my-app  →  C--Users-ok-Desktop-my-app
-        //   Unix:    /Users/ok/dev/my-app         →  -Users-ok-dev-my-app
+        //   Windows: C:\Users\alice\Desktop\my-app  →  C--Users-alice-Desktop-my-app
+        //   Unix:    /Users/alice/dev/my-app         →  -Users-alice-dev-my-app
         const encodedCwd = projectCwd
             .replace(/\\/g, "/") // normalize backslashes to forward slashes
             .replace(/:\//g, "--") // drive letter: C:/ → C--

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-setup",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "Setup layer for Claude Code — reads your project, writes command files, Claude Code does the rest",
   "type": "module",
   "bin": {

package/templates/sync.md

@@ -1,5 +1,9 @@
 <!-- claude-setup sync {{DATE}} | last: {{LAST_RUN_DATE}} -->
 
+> **Step 1 — always do this first:** Run `npx claude-setup sync` to refresh this file with the latest diff.
+> - If it outputs "No changes since…" → respond "Stack already in sync." and STOP.
+> - Otherwise → re-read `.claude/commands/stack-sync.md` (Step 2), then process the diff below (Step 3).
+
 Project changed since last setup. Update ONLY what the changes demand.
 
 ## Changes since last setup
@@ -34,16 +38,20 @@ Skills: {{SKILLS_LIST}} | Commands: {{COMMANDS_LIST}} | Workflows: {{WORKFLOWS_L
 
 ## Your job
 
-For EACH changed file: does this change have any implication for the Claude Code setup?
+For EACH changed file, update the Claude Code setup:
+
+**Source files added/removed/modified — ALWAYS update CLAUDE.md:**
+- New source directories or modules → add to key dirs section
+- New routes, services, controllers → document the new endpoints/patterns
+- New dependencies or frameworks → update runtime section
+- Renamed or restructured files → update stale paths
+- CLAUDE.md must reflect the CURRENT project structure, not just config files
 
-Reason about the signal:
+**Config and infrastructure changes:**
 - New dependency → new MCP server needed? New hook justified?
 - New docker-compose service → new MCP entry? Env vars changed?
-- Source file added/removed → CLAUDE.md paths stale? Skill still applies?
 - Config deleted → remove its MCP/hook reference if it was the only evidence?
 
-Update ONLY what the change demands.
-Do NOT update things that did not change.
 Do NOT rewrite files — surgical edits only.
 If unsure about a change's implication: flag it, don't guess.