claude-setup 1.1.4 → 1.1.6

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,24 +85,61 @@ 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);
     writeTimeline(cwd, timeline);
     writeNodeData(cwd, nodeId, data);
     return node;
 }
+/**
+ * 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);
+        if (data) {
+            for (const [filePath, content] of Object.entries(data.files)) {
+                cumulative[filePath] = content;
+            }
+        }
+    }
+    return cumulative;
+}
 /**
  * Restore files from a snapshot node.
- * Writes stored file contents back to disk.
+ * Accumulates all file states from node 0 through the target node,
+ * then writes them to disk. This reconstructs the full project state
+ * at that point in time, not just the delta.
  * Does NOT delete other nodes — all nodes are preserved (like git).
  */
-export function restoreSnapshot(cwd, nodeId) {
-    const data = readNodeData(cwd, nodeId);
-    if (!data)
-        return { restored: [], failed: [nodeId] };
+export function restoreSnapshot(cwd, nodeId, timeline) {
+    const tl = timeline ?? readTimeline(cwd);
+    const cumulativeFiles = buildCumulativeState(cwd, nodeId, tl);
+    if (!cumulativeFiles)
+        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(data.files)) {
+    for (const [filePath, content] of Object.entries(cumulativeFiles)) {
         const fullPath = join(cwd, filePath);
         try {
             const dir = dirname(fullPath);
@@ -115,7 +152,36 @@ export function restoreSnapshot(cwd, nodeId) {
             failed.push(filePath);
         }
     }
-    return { restored, failed };
+    // 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 = [];
+    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);
+        }
+        catch {
+            stale.push(f.path); // couldn't delete (permissions etc.)
+        }
+    }
+    return { restored, failed, deleted, stale };
+}
+/**
+ * Record the last restored node in the timeline (for display purposes).
+ */
+export function updateRestoredNode(cwd, nodeId) {
+    const timeline = readTimeline(cwd);
+    timeline.restoredTo = nodeId;
+    writeTimeline(cwd, timeline);
 }
 /**
  * Compare two snapshot nodes. Returns files that differ between them.
@@ -156,40 +222,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.d.ts

@@ -1,13 +1,20 @@
 /**
  * Token cost tracking — visibility into what every command costs.
  *
- * Zero extra API calls. Token count is computed from content length.
- * Estimates are based on ~4 chars per token approximation.
+ * Two data sources:
+ *   1. Estimates: computed from content length (~4 chars/token)
+ *   2. Real usage: parsed from Claude Code JSONL session transcripts
+ *      stored at ~/.config/claude/projects/ and ~/.claude/projects/
  *
- * Supports all pricing models:
- *   - Opus:   $15/M input
- *   - Sonnet: $3/M input
- *   - Haiku:  $0.25/M input
+ * Pricing engine inspired by ccusage (github.com/syunmoca/ccusage):
+ *   - Per-model pricing with tiered rates (200k token threshold)
+ *   - Cache creation/read tokens tracked separately
+ *   - Per-session, per-project, per-model breakdowns
+ *
+ * Current pricing (per million tokens):
+ *   Opus 4.6:   $15 input / $75 output / $18.75 cache-write / $1.50 cache-read
+ *   Sonnet 4.6: $3 input  / $15 output / $3.75 cache-write  / $0.30 cache-read
+ *   Haiku 4.5:  $0.80 input / $4 output / $1.00 cache-write / $0.08 cache-read
  */
 export interface CostBreakdown {
     opus: number;
@@ -22,6 +29,8 @@ export interface TokenEstimate {
         tokens: number;
     }>;
 }
+/** Calculate real cost for a set of token counts using a specific model */
+export declare function calculateRealCost(inputTokens: number, outputTokens: number, cacheCreate: number, cacheRead: number, modelName: string): number;
 export declare function estimateTokens(content: string): number;
 export declare function estimateCost(tokens: number): CostBreakdown;
 export declare function formatCost(cost: CostBreakdown): string;
@@ -43,6 +52,66 @@ export declare function generateHints(runs: Array<{
     command: string;
     estimatedTokens?: number;
 }>, currentTokens: number, budget: number): string[];
+export interface RealTokenRecord {
+    sessionId: string;
+    timestamp: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreate: number;
+    cacheRead: number;
+    cost: number;
+}
+export declare function readRealTokenUsage(cwd: string): RealTokenRecord[];
+export interface ModelBreakdown {
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreateTokens: number;
+    cacheReadTokens: number;
+    cost: number;
+    totalTokens: number;
+}
+export interface SessionSummary {
+    sessionId: string;
+    project: string;
+    timestamp: string;
+    models: ModelBreakdown[];
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreateTokens: number;
+    cacheReadTokens: number;
+    totalTokens: number;
+    totalCost: number;
+}
+export interface ProjectSummary {
+    project: string;
+    sessions: number;
+    models: ModelBreakdown[];
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreateTokens: number;
+    cacheReadTokens: number;
+    totalTokens: number;
+    totalCost: number;
+}
+/**
+ * Read all JSONL session files for a given project directory.
+ * Scans Claude's data directories for matching project paths.
+ * Returns per-session summaries with per-model breakdowns.
+ */
+export declare function readProjectSessions(projectCwd: string): SessionSummary[];
+/**
+ * Aggregate all sessions for a project into a single summary.
+ */
+export declare function getProjectUsageSummary(projectCwd: string): ProjectSummary | null;
+export declare function getTokenHookScript(): string;
+/**
+ * Format a real-cost summary. Prefers JSONL transcript data (ccusage-style),
+ * falls back to Stop hook data if no JSONL sessions found.
+ * Returns null if no real data is available from either source.
+ */
+export declare function formatRealCostSummary(cwd: string): string | null;
 /**
  * Compute cumulative stats for status dashboard.
  */