claude-setup 1.1.2 → 1.1.4

package/dist/commands/status.js

@@ -1,6 +1,10 @@
+import { readFileSync, existsSync } from "fs";
+import { basename, join } from "path";
 import { readManifest } from "../manifest.js";
 import { readState } from "../state.js";
 import { detectOS } from "../os.js";
+import { readTimeline } from "../snapshot.js";
+import { computeCumulativeStats, formatCost } from "../tokens.js";
 import { c, statusLine, section } from "../output.js";
 function safeJsonParse(content) {
     try {
@@ -23,10 +27,13 @@ export async function runStatus() {
     // --- Header ---
     console.log(c.bold("status") + ` — ${new Date().toISOString().split("T")[0]}\n`);
     // --- Project info ---
-    const projectType = inferProjectType(state);
-    console.log(`Project : ${projectType}`);
-    console.log(`OS      : ${os}`);
-    console.log(`Version : claude-setup v${version}`);
+    // BUG 2 FIX: Use directory name or package manifest name, not language
+    const projectName = getProjectName();
+    const language = inferLanguage(state);
+    console.log(`Project  : ${projectName}`);
+    console.log(`Language : ${language}`);
+    console.log(`OS       : ${os}`);
+    console.log(`Version  : claude-setup v${version}`);
     // --- Setup files ---
     section("Setup files");
     // CLAUDE.md
@@ -50,14 +57,7 @@ export async function runStatus() {
     // settings.json
     if (state.settings.exists && state.settings.content) {
         const settings = safeJsonParse(state.settings.content);
-        let hookCount = 0;
-        if (settings) {
-            for (const key of ["PreToolUse", "PostToolUse", "PreCompact", "PostCompact", "Notification", "Stop", "SubagentStop"]) {
-                const hooks = settings[key];
-                if (Array.isArray(hooks))
-                    hookCount += hooks.length;
-            }
-        }
+        const hookCount = countHooks(settings);
         statusLine("✅", "settings.json", `${hookCount} hook(s)`);
     }
     else {
@@ -67,11 +67,64 @@ export async function runStatus() {
     console.log(`  Skills    : ${state.skills.length ? state.skills.map(s => s.split("/").at(-2) ?? s).join(", ") : "none"}`);
     console.log(`  Commands  : ${state.commands.length ? state.commands.map(s => s.split("/").pop()?.replace(".md", "") ?? s).join(", ") : "none"}`);
     console.log(`  Workflows : ${state.workflows.length ? state.workflows.map(s => s.split("/").pop() ?? s).join(", ") : "none"}`);
+    // --- Feature A/B: Snapshot timeline ---
+    const cwd = process.cwd();
+    const timeline = readTimeline(cwd);
+    if (timeline.nodes.length > 0) {
+        section("Snapshot timeline");
+        const displayNodes = timeline.nodes.slice(-8); // Show last 8
+        if (timeline.nodes.length > 8) {
+            console.log(`  ${c.dim(`... +${timeline.nodes.length - 8} older snapshots`)}`);
+        }
+        for (let i = 0; i < displayNodes.length; i++) {
+            const node = displayNodes[i];
+            const date = new Date(node.timestamp).toLocaleDateString();
+            const time = new Date(node.timestamp).toLocaleTimeString();
+            const isLatest = i === displayNodes.length - 1;
+            const marker = isLatest ? ` ${c.green("← current")}` : "";
+            const inputStr = node.input ? ` "${node.input}"` : "";
+            console.log(`  ${c.cyan(node.id)}  ${node.command}${inputStr}  ${c.dim(`${date} ${time}`)}  ${node.summary}${marker}`);
+        }
+        console.log(`\n  ${c.dim("Use")} ${c.cyan("npx claude-setup restore")} ${c.dim("to jump to any snapshot")}`);
+        console.log(`  ${c.dim("Use")} ${c.cyan("npx claude-setup compare")} ${c.dim("to diff two snapshots")}`);
+    }
+    // --- Feature I: Token usage stats ---
+    const runsWithTokens = manifest.runs.filter(r => r.estimatedTokens !== undefined);
+    if (runsWithTokens.length > 0) {
+        section("Token usage");
+        const stats = computeCumulativeStats(manifest.runs);
+        console.log(`  Total tokens : ~${stats.totalTokens.toLocaleString()} across ${stats.runCount} run(s)`);
+        console.log(`  Total cost   : ${formatCost(stats.totalCost)}`);
+        // Average by command type
+        const avgEntries = Object.entries(stats.avgByCommand);
+        if (avgEntries.length > 0) {
+            console.log(`  Avg by type  :`);
+            for (const [cmd, avg] of avgEntries) {
+                console.log(`    ${cmd}: ~${avg.toLocaleString()} tokens/run`);
+            }
+        }
+        // Cost trend (last 3 vs previous 3)
+        if (runsWithTokens.length >= 6) {
+            const recent3 = runsWithTokens.slice(-3);
+            const prev3 = runsWithTokens.slice(-6, -3);
+            const recentAvg = recent3.reduce((s, r) => s + (r.estimatedTokens ?? 0), 0) / 3;
+            const prevAvg = prev3.reduce((s, r) => s + (r.estimatedTokens ?? 0), 0) / 3;
+            const change = ((recentAvg - prevAvg) / prevAvg) * 100;
+            if (Math.abs(change) > 10) {
+                const trend = change > 0 ? c.yellow(`↑ +${change.toFixed(0)}%`) : c.green(`↓ ${change.toFixed(0)}%`);
+                console.log(`  Trend        : ${trend} (recent vs previous)`);
+            }
+            else {
+                console.log(`  Trend        : ${c.green("→ stable")}`);
+            }
+        }
+    }
     // --- Run history ---
     section("Run history (last 5)");
     for (const r of manifest.runs.slice(-5)) {
         const inputStr = r.input ? ` — "${r.input}"` : "";
-        console.log(`  ${c.dim(r.at)}  ${r.command}${inputStr}`);
+        const tokenStr = r.estimatedTokens ? ` (${r.estimatedTokens.toLocaleString()} tokens)` : "";
+        console.log(`  ${c.dim(r.at)}  ${r.command}${inputStr}${tokenStr}`);
     }
     // --- Health hint ---
     const hint = getHealthHint(manifest, state);
@@ -87,9 +140,130 @@ export async function runStatus() {
     }
     console.log("");
 }
-function inferProjectType(state) {
+/**
+ * BUG 3 FIX: Count hooks across all event types, handling both formats:
+ * - Correct format: { "hooks": { "PostToolUse": [{ "matcher": "...", "hooks": [{ "type": "command", "command": "..." }] }] } }
+ * - Legacy/flat format: { "PostToolUse": [{ "command": "...", "args": [...] }] }
+ */
+function countHooks(settings) {
+    if (!settings)
+        return 0;
+    let count = 0;
+    const HOOK_EVENTS = [
+        "PreToolUse", "PostToolUse", "PostToolUseFailure", "Stop", "SessionStart",
+        "Notification", "SubagentStart", "SubagentStop", "UserPromptSubmit",
+        "PermissionRequest", "ConfigChange", "InstructionsLoaded", "TaskCompleted",
+        "TeammateIdle", "StopFailure", "SessionEnd",
+        "PreCompact", "PostCompact", "WorktreeCreate", "WorktreeRemove",
+        "Elicitation", "ElicitationResult",
+    ];
+    // Check inside "hooks" key first (correct Claude Code format)
+    const hooksObj = settings["hooks"];
+    if (hooksObj && typeof hooksObj === "object") {
+        for (const event of HOOK_EVENTS) {
+            const eventHooks = hooksObj[event];
+            if (Array.isArray(eventHooks)) {
+                for (const entry of eventHooks) {
+                    if (typeof entry === "object" && entry !== null) {
+                        const e = entry;
+                        if (Array.isArray(e.hooks)) {
+                            count += e.hooks.length;
+                        }
+                        else {
+                            count++;
+                        }
+                    }
+                }
+            }
+        }
+        return count;
+    }
+    // Fallback: check top-level keys (legacy flat format)
+    for (const event of HOOK_EVENTS) {
+        const hooks = settings[event];
+        if (Array.isArray(hooks)) {
+            for (const entry of hooks) {
+                if (typeof entry === "object" && entry !== null) {
+                    const e = entry;
+                    if (Array.isArray(e.hooks)) {
+                        count += e.hooks.length;
+                    }
+                    else {
+                        count++;
+                    }
+                }
+            }
+        }
+    }
+    return count;
+}
+/** BUG 2 FIX: Get project name from package manifest or directory name */
+function getProjectName() {
+    const cwd = process.cwd();
+    // Try package.json name
+    try {
+        const pkgPath = join(cwd, "package.json");
+        if (existsSync(pkgPath)) {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+            if (pkg.name)
+                return pkg.name;
+        }
+    }
+    catch { /* skip */ }
+    // Try pom.xml artifactId
+    try {
+        const pomPath = join(cwd, "pom.xml");
+        if (existsSync(pomPath)) {
+            const pom = readFileSync(pomPath, "utf8");
+            const match = pom.match(/<artifactId>([^<]+)<\/artifactId>/);
+            if (match)
+                return match[1];
+        }
+    }
+    catch { /* skip */ }
+    // Try Cargo.toml name
+    try {
+        const cargoPath = join(cwd, "Cargo.toml");
+        if (existsSync(cargoPath)) {
+            const cargo = readFileSync(cargoPath, "utf8");
+            const match = cargo.match(/^name\s*=\s*"([^"]+)"/m);
+            if (match)
+                return match[1];
+        }
+    }
+    catch { /* skip */ }
+    // Try pyproject.toml name
+    try {
+        const pyPath = join(cwd, "pyproject.toml");
+        if (existsSync(pyPath)) {
+            const py = readFileSync(pyPath, "utf8");
+            const match = py.match(/^name\s*=\s*"([^"]+)"/m);
+            if (match)
+                return match[1];
+        }
+    }
+    catch { /* skip */ }
+    // Fallback: directory name
+    return basename(cwd);
+}
+/** Detect language/runtime as a separate field */
+function inferLanguage(state) {
+    const cwd = process.cwd();
+    if (existsSync(join(cwd, "package.json")))
+        return "Node.js / TypeScript";
+    if (existsSync(join(cwd, "pyproject.toml")) || existsSync(join(cwd, "requirements.txt")))
+        return "Python";
+    if (existsSync(join(cwd, "go.mod")))
+        return "Go";
+    if (existsSync(join(cwd, "Cargo.toml")))
+        return "Rust";
+    if (existsSync(join(cwd, "pom.xml")) || existsSync(join(cwd, "build.gradle")))
+        return "Java";
+    if (existsSync(join(cwd, "Gemfile")))
+        return "Ruby";
+    if (existsSync(join(cwd, "composer.json")))
+        return "PHP";
     if (state.claudeMd.content) {
-        // Try to infer from CLAUDE.md content
         const content = state.claudeMd.content.toLowerCase();
         if (content.includes("typescript") || content.includes("node"))
             return "Node.js / TypeScript";
@@ -111,7 +285,6 @@ function getHealthHint(manifest, _state) {
     if (!last)
         return `${c.yellow("⚠️")}  No runs recorded. Run: ${c.cyan("npx claude-setup init")}`;
     const daysSince = Math.floor((Date.now() - new Date(last.at).getTime()) / (1000 * 60 * 60 * 24));
-    // Check for recent deletions
     if (last.command === "sync") {
         const snapshot = last.snapshot;
         const deletionCount = Object.keys(snapshot).filter(k => k.startsWith("[deleted]")).length;

package/dist/commands/sync.d.ts

@@ -1,3 +1,4 @@
 export declare function runSync(opts?: {
     dryRun?: boolean;
+    budget?: number;
 }): Promise<void>;

package/dist/commands/sync.js

@@ -1,9 +1,13 @@
-import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
 import { collectProjectFiles } from "../collect.js";
 import { readState } from "../state.js";
 import { readManifest, sha256, updateManifest } from "../manifest.js";
 import { buildSyncCommand } from "../builder.js";
-import { c } from "../output.js";
+import { createSnapshot, collectFilesForSnapshot } from "../snapshot.js";
+import { estimateTokens, estimateCost, formatTokenReport, buildTokenEstimate, generateHints } from "../tokens.js";
+import { loadConfig } from "../config.js";
+import { c, section } from "../output.js";
 function ensureDir(dir) {
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
@@ -13,7 +17,7 @@ function truncate(content, maxChars) {
         return content;
     return content.slice(0, maxChars) + "\n[... truncated for sync diff]";
 }
-function computeDiff(snapshot, collected) {
+function computeDiff(snapshot, collected, cwd) {
     const current = {
         ...collected.configs,
         ...Object.fromEntries(collected.source.map(f => [f.path, f.content])),
@@ -33,12 +37,38 @@ function computeDiff(snapshot, collected) {
             changed.push({ path, current: truncate(content, 2000) });
         }
     }
+    // BUG 1 FIX: Verify file existence on disk before reporting deletions.
+    // Files may appear "deleted" because they weren't in the current collection set
+    // (different collect mode, or CLI-managed files like CLAUDE.md/settings.json).
+    // If the file still exists on disk, it was "modified outside the CLI", not deleted.
     for (const path of Object.keys(snapshot)) {
         // Skip virtual keys
         if (path === "__digest__")
             continue;
-        if (!current[path])
-            deleted.push(path);
+        if (!current[path]) {
+            // Check if file actually exists on disk
+            const fullPath = join(cwd, path);
+            if (existsSync(fullPath)) {
+                // File exists but wasn't in our collection — it was modified outside CLI
+                // Read it and check if its hash changed
+                try {
+                    const diskContent = readFileSync(fullPath, "utf8");
+                    const diskHash = sha256(diskContent);
+                    if (snapshot[path] !== diskHash) {
+                        changed.push({ path, current: truncate(diskContent, 2000) });
+                    }
+                    // If hash matches, file is unchanged — don't report anything
+                }
+                catch {
+                    // Can't read — treat as changed
+                    changed.push({ path, current: "[file exists but could not be read]" });
+                }
+            }
+            else {
+                // File genuinely does not exist on disk — truly deleted
+                deleted.push(path);
+            }
+        }
     }
     return { added, changed, deleted };
 }
@@ -50,14 +80,47 @@ export async function runSync(opts = {}) {
         return;
     }
     const lastRun = manifest.runs.at(-1);
-    const collected = await collectProjectFiles(process.cwd(), "normal");
-    const diff = computeDiff(lastRun.snapshot, collected);
-    if (!diff.added.length && !diff.changed.length && !diff.deleted.length) {
+    const cwd = process.cwd();
+    const config = loadConfig(cwd);
+    // Apply --budget override if provided
+    if (opts.budget) {
+        config.tokenBudget.sync = opts.budget;
+    }
+    // --- Out-of-band edit detection ---
+    const managedFiles = [
+        { label: "CLAUDE.md", path: join(cwd, "CLAUDE.md"), snapshotKey: "CLAUDE.md" },
+        { label: ".mcp.json", path: join(cwd, ".mcp.json"), snapshotKey: ".mcp.json" },
+        { label: "settings.json", path: join(cwd, ".claude", "settings.json"), snapshotKey: ".claude/settings.json" },
+    ];
+    let oobDetected = false;
+    for (const mf of managedFiles) {
+        if (!existsSync(mf.path))
+            continue;
+        const currentContent = readFileSync(mf.path, "utf8");
+        const currentHash = sha256(currentContent);
+        const snapshotHash = lastRun.snapshot[mf.snapshotKey];
+        if (snapshotHash && currentHash !== snapshotHash) {
+            if (!oobDetected) {
+                oobDetected = true;
+                console.log("");
+            }
+            console.log(`${c.yellow("⚠️")}  OUT-OF-BAND EDIT — ${mf.label} was modified outside the CLI`);
+            console.log(`    Re-snapshotting. Run ${c.cyan("npx claude-setup doctor")} to validate the new state.`);
+        }
+    }
+    if (oobDetected)
+        console.log("");
+    const collected = await collectProjectFiles(cwd, "normal");
+    const diff = computeDiff(lastRun.snapshot, collected, cwd);
+    if (!diff.added.length && !diff.changed.length && !diff.deleted.length && !oobDetected) {
         console.log(`${c.green("✅")} No changes since ${c.dim(lastRun.at)}. Setup is current.`);
         return;
     }
     const state = await readState();
     const content = buildSyncCommand(diff, collected, state);
+    // Token tracking
+    const tokens = estimateTokens(content);
+    const cost = estimateCost(tokens);
     if (dryRun) {
         console.log(c.bold("[DRY RUN] Changes detected:\n"));
         if (diff.added.length) {
@@ -75,12 +138,26 @@ export async function runSync(opts = {}) {
             for (const f of diff.deleted)
                 console.log(`    ${f}`);
         }
-        console.log(`\n  Would write: .claude/commands/stack-sync.md (~${Math.ceil(content.length / 4)} tokens)`);
+        console.log(`\n  Would write: .claude/commands/stack-sync.md (~${tokens.toLocaleString()} tokens)`);
+        // Token cost display
+        section("Token cost estimate");
+        const estimate = buildTokenEstimate([{ label: "sync command", content }]);
+        console.log(formatTokenReport(estimate));
         return;
     }
     ensureDir(".claude/commands");
     writeFileSync(".claude/commands/stack-sync.md", content, "utf8");
-    await updateManifest("sync", collected);
+    await updateManifest("sync", collected, { estimatedTokens: tokens, estimatedCost: cost });
+    // Feature A: Create snapshot node
+    const allPaths = [
+        ...Object.keys(collected.configs),
+        ...collected.source.map(s => s.path),
+    ];
+    const snapshotFiles = collectFilesForSnapshot(cwd, allPaths);
+    const changeCount = diff.added.length + diff.changed.length + diff.deleted.length;
+    createSnapshot(cwd, "sync", snapshotFiles, {
+        summary: `+${diff.added.length} added, ~${diff.changed.length} modified, -${diff.deleted.length} deleted`,
+    });
     console.log(`
 Changes since ${c.dim(lastRun.at)}:
   ${c.green(`+${diff.added.length}`)} added  ${c.yellow(`~${diff.changed.length}`)} modified  ${c.red(`-${diff.deleted.length}`)} deleted
@@ -88,4 +165,17 @@ Changes since ${c.dim(lastRun.at)}:
 ${c.green("✅")} Ready. Open Claude Code and run:
    ${c.cyan("/stack-sync")}
   `);
+    // Token cost display
+    section("Token cost");
+    console.log(`  ~${tokens.toLocaleString()} input tokens (${c.dim(`Opus $${cost.opus.toFixed(4)} | Sonnet $${cost.sonnet.toFixed(4)} | Haiku $${cost.haiku.toFixed(4)}`)})`);
+    // Optimization hints
+    const runs = manifest.runs.map(r => ({ command: r.command, estimatedTokens: r.estimatedTokens }));
+    const hints = generateHints(runs, tokens, config.tokenBudget.sync);
+    if (hints.length) {
+        section("Optimization hints");
+        for (const hint of hints) {
+            console.log(`  ${c.yellow("💡")} ${hint}`);
+        }
+    }
+    console.log("");
 }

package/dist/doctor.d.ts

@@ -1 +1 @@
-export declare function runDoctor(verbose?: boolean): Promise<void>;
+export declare function runDoctor(verbose?: boolean, fix?: boolean, testHooks?: boolean): Promise<void>;