claude-setup 1.1.3 → 1.1.4

package/dist/commands/export.js

@@ -0,0 +1,289 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, basename } from "path";
+import { readState } from "../state.js";
+import { detectOS } from "../os.js";
+import { c, section } from "../output.js";
+import { createInterface } from "readline";
+async function promptFreeText(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question + " ", (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function runExport() {
+    const cwd = process.cwd();
+    const state = await readState(cwd);
+    const os = detectOS();
+    const name = await promptFreeText("Template name:");
+    if (!name) {
+        console.log("No name provided.");
+        return;
+    }
+    const template = {
+        name,
+        version: "1",
+        exportedAt: new Date().toISOString(),
+        exportedFrom: basename(cwd),
+        os,
+        skills: [],
+        commands: [],
+    };
+    // Capture CLAUDE.md
+    if (state.claudeMd.content) {
+        template.claudeMd = state.claudeMd.content;
+    }
+    // Capture .mcp.json (parsed as object for OS adaptation on import)
+    if (state.mcpJson.content) {
+        try {
+            template.mcpJson = JSON.parse(state.mcpJson.content);
+        }
+        catch { /* skip invalid */ }
+    }
+    // Capture settings.json — never export model key
+    if (state.settings.content) {
+        try {
+            const settings = JSON.parse(state.settings.content);
+            delete settings["model"];
+            template.settings = settings;
+        }
+        catch { /* skip invalid */ }
+    }
+    // Capture skills
+    for (const skillPath of state.skills) {
+        const fullPath = join(cwd, skillPath);
+        if (!existsSync(fullPath))
+            continue;
+        try {
+            const content = readFileSync(fullPath, "utf8");
+            const skillName = skillPath.split("/").at(-2) ?? skillPath.split("/").pop()?.replace(".md", "") ?? skillPath;
+            template.skills.push({ name: skillName, content });
+        }
+        catch { /* skip */ }
+    }
+    // Capture commands (excluding stack-* artifacts)
+    for (const cmdPath of state.commands) {
+        const fullPath = join(cwd, cmdPath);
+        if (!existsSync(fullPath))
+            continue;
+        try {
+            const content = readFileSync(fullPath, "utf8");
+            const cmdName = cmdPath.split("/").pop()?.replace(".md", "") ?? cmdPath;
+            template.commands.push({ name: cmdName, content });
+        }
+        catch { /* skip */ }
+    }
+    const filename = `${name.replace(/[^a-zA-Z0-9_-]/g, "-")}.claude-template.json`;
+    writeFileSync(join(cwd, filename), JSON.stringify(template, null, 2), "utf8");
+    const serverCount = template.mcpJson
+        ? Object.keys(template.mcpJson.mcpServers ?? {}).length
+        : 0;
+    console.log(`
+${c.green("✅")} Template exported: ${c.cyan(filename)}
+
+Contents:
+  CLAUDE.md    : ${template.claudeMd ? "included" : "not found"}
+  .mcp.json    : ${serverCount ? `${serverCount} server(s)` : "not found"}
+  settings.json: ${template.settings ? "included" : "not found"}
+  Skills       : ${template.skills.length}
+  Commands     : ${template.commands.length}
+
+Apply to another project:
+  ${c.cyan(`npx claude-setup init --template ${filename}`)}
+  `);
+}
+/**
+ * Apply a template to the current project.
+ * Merge logic: existing content kept, new content added.
+ * OS adaptation: MCP commands auto-converted for target OS.
+ */
+export async function applyTemplate(templateSource) {
+    const cwd = process.cwd();
+    let templateContent;
+    // Resolve template source — local file or URL
+    if (templateSource.startsWith("http://") || templateSource.startsWith("https://")) {
+        try {
+            const response = await fetch(templateSource);
+            if (!response.ok) {
+                console.log(`${c.red("🔴")} Failed to fetch template: HTTP ${response.status}`);
+                return;
+            }
+            templateContent = await response.text();
+        }
+        catch (err) {
+            console.log(`${c.red("🔴")} Failed to fetch template: ${err}`);
+            return;
+        }
+    }
+    else {
+        // Try relative to cwd first, then absolute
+        const resolved = existsSync(join(cwd, templateSource))
+            ? join(cwd, templateSource)
+            : existsSync(templateSource)
+                ? templateSource
+                : null;
+        if (!resolved) {
+            console.log(`${c.red("🔴")} Template not found: ${templateSource}`);
+            return;
+        }
+        templateContent = readFileSync(resolved, "utf8");
+    }
+    let template;
+    try {
+        template = JSON.parse(templateContent);
+    }
+    catch {
+        console.log(`${c.red("🔴")} Invalid template JSON.`);
+        return;
+    }
+    const targetOS = detectOS();
+    let applied = 0;
+    section(`Applying template: ${template.name}`);
+    console.log(`  Source OS: ${template.os} → Target OS: ${targetOS}\n`);
+    // 1. CLAUDE.md — append only, never remove existing lines
+    if (template.claudeMd) {
+        const claudeMdPath = join(cwd, "CLAUDE.md");
+        if (existsSync(claudeMdPath)) {
+            const existing = readFileSync(claudeMdPath, "utf8");
+            const newLines = template.claudeMd
+                .split("\n")
+                .filter(l => l.trim() && !existing.includes(l.trim()));
+            if (newLines.length) {
+                writeFileSync(claudeMdPath, existing + "\n\n# From template: " + template.name + "\n" + newLines.join("\n") + "\n", "utf8");
+                console.log(`  ${c.green("✅")} CLAUDE.md — appended ${newLines.length} line(s)`);
+                applied++;
+            }
+            else {
+                console.log(`  ${c.dim("⏭")} CLAUDE.md — all content already present`);
+            }
+        }
+        else {
+            writeFileSync(claudeMdPath, template.claudeMd, "utf8");
+            console.log(`  ${c.green("✅")} CLAUDE.md — created`);
+            applied++;
+        }
+    }
+    // 2. .mcp.json — merge servers, adapt OS format
+    if (template.mcpJson) {
+        const mcpPath = join(cwd, ".mcp.json");
+        let existing = {};
+        if (existsSync(mcpPath)) {
+            try {
+                existing = JSON.parse(readFileSync(mcpPath, "utf8"));
+            }
+            catch { /* start fresh */ }
+        }
+        const existingServers = (existing.mcpServers ?? {});
+        const templateServers = ((template.mcpJson).mcpServers ?? {});
+        let addedCount = 0;
+        for (const [name, config] of Object.entries(templateServers)) {
+            if (existingServers[name]) {
+                console.log(`  ${c.dim("⏭")} MCP server: ${name} — already exists`);
+                continue;
+            }
+            existingServers[name] = adaptMcpForOS(config, template.os, targetOS);
+            console.log(`  ${c.green("✅")} MCP server: ${name} — added (OS-adapted)`);
+            addedCount++;
+        }
+        if (addedCount > 0) {
+            existing.mcpServers = existingServers;
+            writeFileSync(mcpPath, JSON.stringify(existing, null, 2), "utf8");
+            applied++;
+        }
+    }
+    // 3. settings.json — merge hooks, never write model key
+    if (template.settings) {
+        const settingsDir = join(cwd, ".claude");
+        const settingsPath = join(settingsDir, "settings.json");
+        if (!existsSync(settingsDir))
+            mkdirSync(settingsDir, { recursive: true });
+        let existing = {};
+        if (existsSync(settingsPath)) {
+            try {
+                existing = JSON.parse(readFileSync(settingsPath, "utf8"));
+            }
+            catch { /* start fresh */ }
+        }
+        const templateHooks = (template.settings.hooks ?? {});
+        const existingHooks = (existing.hooks ?? {});
+        let addedHooks = 0;
+        for (const [event, hooks] of Object.entries(templateHooks)) {
+            if (!existingHooks[event]) {
+                existingHooks[event] = hooks;
+                addedHooks += Array.isArray(hooks) ? hooks.length : 0;
+                console.log(`  ${c.green("✅")} Hook: ${event} — added`);
+            }
+            else {
+                console.log(`  ${c.dim("⏭")} Hook: ${event} — already exists`);
+            }
+        }
+        if (addedHooks > 0) {
+            existing.hooks = existingHooks;
+            delete existing["model"]; // Never write model key
+            writeFileSync(settingsPath, JSON.stringify(existing, null, 2), "utf8");
+            applied++;
+        }
+    }
+    // 4. Skills — skip if same name exists
+    for (const skill of template.skills) {
+        const skillDir = join(cwd, ".claude", "skills", skill.name);
+        const skillPath = join(skillDir, "SKILL.md");
+        if (existsSync(skillPath)) {
+            console.log(`  ${c.dim("⏭")} Skill: ${skill.name} — already exists`);
+            continue;
+        }
+        mkdirSync(skillDir, { recursive: true });
+        writeFileSync(skillPath, skill.content, "utf8");
+        console.log(`  ${c.green("✅")} Skill: ${skill.name} — created`);
+        applied++;
+    }
+    // 5. Commands — skip if same name exists
+    for (const cmd of template.commands) {
+        const cmdDir = join(cwd, ".claude", "commands");
+        const cmdPath = join(cmdDir, `${cmd.name}.md`);
+        if (existsSync(cmdPath)) {
+            console.log(`  ${c.dim("⏭")} Command: ${cmd.name} — already exists`);
+            continue;
+        }
+        if (!existsSync(cmdDir))
+            mkdirSync(cmdDir, { recursive: true });
+        writeFileSync(cmdPath, cmd.content, "utf8");
+        console.log(`  ${c.green("✅")} Command: ${cmd.name} — created`);
+        applied++;
+    }
+    console.log(`\n${c.green("✅")} Template "${template.name}" applied — ${applied} item(s) added.`);
+}
+/**
+ * Adapt MCP server config for target OS.
+ * Templates are stored with the source OS format.
+ * On import, commands are auto-converted:
+ *   Windows → macOS/Linux: cmd /c npx → npx
+ *   macOS/Linux → Windows: npx → cmd /c npx
+ * Path separators and env var syntax are also adapted.
+ */
+function adaptMcpForOS(config, sourceOS, targetOS) {
+    if (sourceOS === targetOS)
+        return config;
+    const result = { ...config };
+    const cmd = config.command;
+    const args = [...(config.args ?? [])];
+    if (!cmd)
+        return result;
+    // Source is Windows → target is macOS/Linux
+    if (sourceOS === "Windows" && targetOS !== "Windows") {
+        if (cmd === "cmd" && args[0] === "/c") {
+            result.command = args[1]; // "npx", "bun", etc.
+            result.args = args.slice(2);
+        }
+    }
+    // Source is macOS/Linux → target is Windows
+    if (sourceOS !== "Windows" && targetOS === "Windows") {
+        if (cmd === "npx" || cmd === "bun" || cmd === "node") {
+            result.command = "cmd";
+            result.args = ["/c", cmd, ...args];
+        }
+    }
+    return result;
+}

package/dist/commands/init.d.ts

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

package/dist/commands/init.js

@@ -4,16 +4,24 @@ import { collectProjectFiles, isEmptyProject } from "../collect.js";
 import { readState } from "../state.js";
 import { updateManifest } from "../manifest.js";
 import { buildEmptyProjectCommand, buildAtomicSteps, buildOrchestratorCommand, } from "../builder.js";
-import { c } from "../output.js";
+import { createSnapshot, collectFilesForSnapshot } from "../snapshot.js";
+import { estimateTokens, estimateCost } from "../tokens.js";
+import { c, section } from "../output.js";
 import { ensureConfig } from "../config.js";
+import { applyTemplate } from "./export.js";
 function ensureDir(dir) {
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
 }
 export async function runInit(opts = {}) {
     const dryRun = opts.dryRun ?? false;
+    // Feature H: --template flag — apply a template instead of scanning
+    if (opts.template) {
+        console.log(`Applying template: ${c.cyan(opts.template)}\n`);
+        await applyTemplate(opts.template);
+        return;
+    }
     // Auto-generate .claude-setup.json if it doesn't exist
-    // Developer can edit it anytime to tune token budgets, truncation rules, etc.
     const configCreated = ensureConfig();
     if (configCreated) {
         console.log(`${c.dim("Created .claude-setup.json — edit to tune token budgets and truncation rules")}`);
@@ -22,18 +30,28 @@ export async function runInit(opts = {}) {
     const collected = await collectProjectFiles(process.cwd(), "deep");
     if (isEmptyProject(collected)) {
         const content = buildEmptyProjectCommand();
+        // Token tracking
+        const tokens = estimateTokens(content);
+        const cost = estimateCost(tokens);
         if (dryRun) {
             console.log(c.bold("[DRY RUN] Would write:\n"));
-            console.log(`  .claude/commands/stack-init.md (${content.length} chars, ~${Math.ceil(content.length / 4)} tokens)`);
+            console.log(`  .claude/commands/stack-init.md (${content.length} chars, ~${tokens.toLocaleString()} tokens)`);
             console.log(`\n${c.dim("--- preview ---")}`);
             console.log(content.slice(0, 500));
             if (content.length > 500)
                 console.log(c.dim(`\n... +${content.length - 500} chars`));
+            section("Token cost estimate");
+            console.log(`  ~${tokens.toLocaleString()} input tokens (Opus $${cost.opus.toFixed(4)} | Sonnet $${cost.sonnet.toFixed(4)} | Haiku $${cost.haiku.toFixed(4)})`);
             return;
         }
         ensureDir(".claude/commands");
         writeFileSync(".claude/commands/stack-init.md", content, "utf8");
-        await updateManifest("init", collected);
+        await updateManifest("init", collected, { estimatedTokens: tokens, estimatedCost: cost });
+        // Feature A: Create initial snapshot node
+        const cwd = process.cwd();
+        const allPaths = [...Object.keys(collected.configs), ...collected.source.map(s => s.path)];
+        const snapshotFiles = collectFilesForSnapshot(cwd, allPaths);
+        createSnapshot(cwd, "init", snapshotFiles, { summary: "initial setup (empty project)" });
         console.log(`
 ${c.green("✅")} New project detected.
 
@@ -42,20 +60,28 @@ Open Claude Code and run:
 
 Claude Code will ask 3 questions, then set up your environment.
     `);
+        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)}`)})`);
+        console.log("");
         return;
     }
     // Standard init — atomic steps + orchestrator
     const steps = buildAtomicSteps(collected, state);
     const orchestrator = buildOrchestratorCommand(steps);
+    // Token tracking — sum all steps
+    const totalContent = steps.map(s => s.content).join("\n") + "\n" + orchestrator;
+    const tokens = estimateTokens(totalContent);
+    const cost = estimateCost(tokens);
     if (dryRun) {
         console.log(c.bold("[DRY RUN] Would write:\n"));
         for (const step of steps) {
-            const tokens = Math.ceil(step.content.length / 4);
-            console.log(`  .claude/commands/${step.filename} (${step.content.length} chars, ~${tokens} tokens)`);
+            const stepTokens = estimateTokens(step.content);
+            console.log(`  .claude/commands/${step.filename} (${step.content.length} chars, ~${stepTokens.toLocaleString()} tokens)`);
         }
         console.log(`  .claude/commands/stack-init.md (orchestrator)`);
-        const totalTokens = steps.reduce((sum, s) => sum + Math.ceil(s.content.length / 4), 0);
-        console.log(`\n${c.dim(`Total: ~${totalTokens} tokens across ${steps.length} files`)}`);
+        console.log(`\n${c.dim(`Total: ~${tokens.toLocaleString()} tokens across ${steps.length} files`)}`);
+        section("Token cost estimate");
+        console.log(`  ~${tokens.toLocaleString()} input tokens (Opus $${cost.opus.toFixed(4)} | Sonnet $${cost.sonnet.toFixed(4)} | Haiku $${cost.haiku.toFixed(4)})`);
         return;
     }
     ensureDir(".claude/commands");
@@ -63,11 +89,21 @@ Claude Code will ask 3 questions, then set up your environment.
         writeFileSync(join(".claude/commands", step.filename), step.content, "utf8");
     }
     writeFileSync(".claude/commands/stack-init.md", orchestrator, "utf8");
-    await updateManifest("init", collected);
+    await updateManifest("init", collected, { estimatedTokens: tokens, estimatedCost: cost });
+    // Feature A: Create initial snapshot node
+    const cwd = process.cwd();
+    const allPaths = [...Object.keys(collected.configs), ...collected.source.map(s => s.path)];
+    const snapshotFiles = collectFilesForSnapshot(cwd, allPaths);
+    createSnapshot(cwd, "init", snapshotFiles, {
+        summary: `${steps.length - 1} atomic steps generated`,
+    });
     console.log(`
 ${c.green("✅")} Ready. Open Claude Code and run:
    ${c.cyan("/stack-init")}
 
 Runs ${steps.length - 1} atomic steps. If one fails, re-run only that step.
   `);
+    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)}`)})`);
+    console.log("");
 }

package/dist/commands/remove.js

@@ -4,7 +4,8 @@ import { collectProjectFiles } from "../collect.js";
 import { readState } from "../state.js";
 import { updateManifest } from "../manifest.js";
 import { buildRemoveCommand } from "../builder.js";
-import { c } from "../output.js";
+import { estimateTokens, estimateCost } from "../tokens.js";
+import { c, section } from "../output.js";
 function ensureDir(dir) {
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
@@ -27,8 +28,18 @@ export async function runRemove() {
     const state = await readState();
     const collected = await collectProjectFiles(process.cwd(), "configOnly");
     const content = buildRemoveCommand(userInput, state);
+    // Token tracking
+    const tokens = estimateTokens(content);
+    const cost = estimateCost(tokens);
     ensureDir(".claude/commands");
     writeFileSync(".claude/commands/stack-remove.md", content, "utf8");
-    await updateManifest("remove", collected, { input: userInput });
-    console.log(`\n${c.green("✅")} Ready. Open Claude Code and run:\n   ${c.cyan("/stack-remove")}\n`);
+    await updateManifest("remove", collected, {
+        input: userInput,
+        estimatedTokens: tokens,
+        estimatedCost: cost,
+    });
+    console.log(`\n${c.green("✅")} Ready. Open Claude Code and run:\n   ${c.cyan("/stack-remove")}`);
+    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)}`)})`);
+    console.log("");
 }

package/dist/commands/restore.d.ts

@@ -0,0 +1 @@
+export declare function runRestore(): Promise<void>;

package/dist/commands/restore.js

@@ -0,0 +1,61 @@
+import { readTimeline, restoreSnapshot } from "../snapshot.js";
+import { c, section } from "../output.js";
+import { createInterface } from "readline";
+async function promptFreeText(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question + " ", (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function runRestore() {
+    const cwd = process.cwd();
+    const timeline = readTimeline(cwd);
+    if (!timeline.nodes.length) {
+        console.log(`${c.yellow("⚠️")} No snapshots found. Run ${c.cyan("npx claude-setup sync")} to create one.`);
+        return;
+    }
+    // Display timeline
+    section("Snapshot timeline");
+    console.log("");
+    for (let i = 0; i < timeline.nodes.length; i++) {
+        const node = timeline.nodes[i];
+        const date = new Date(node.timestamp).toLocaleString();
+        const current = i === timeline.nodes.length - 1 ? ` ${c.green("← current")}` : "";
+        const connector = i < timeline.nodes.length - 1 ? "──→" : "   ";
+        const inputStr = node.input ? ` "${node.input}"` : "";
+        console.log(`  ${c.cyan(node.id)}  ${node.command}${inputStr}  ${c.dim(date)}  ${node.summary}${current}`);
+        if (i < timeline.nodes.length - 1)
+            console.log(`  ${c.dim(connector)}`);
+    }
+    console.log("");
+    const input = await promptFreeText("Enter snapshot ID to restore (or 'cancel'):");
+    if (!input || input === "cancel") {
+        console.log("Cancelled.");
+        return;
+    }
+    const node = timeline.nodes.find(n => n.id === input);
+    if (!node) {
+        console.log(`${c.red("🔴")} Snapshot "${input}" not found.`);
+        return;
+    }
+    console.log(`\nRestoring to snapshot ${c.cyan(node.id)} (${new Date(node.timestamp).toLocaleString()})...`);
+    console.log(`${c.dim("Other snapshots are preserved — you can jump forward or back at any time.")}\n`);
+    const result = restoreSnapshot(cwd, input);
+    if (result.restored.length) {
+        section("Restored files");
+        for (const f of result.restored) {
+            console.log(`  ${c.green("✅")} ${f}`);
+        }
+    }
+    if (result.failed.length) {
+        section("Failed to restore");
+        for (const f of result.failed) {
+            console.log(`  ${c.red("🔴")} ${f}`);
+        }
+    }
+    console.log(`\n${c.green("✅")} Restored ${result.restored.length} file(s) to snapshot ${c.cyan(node.id)}.`);
+    console.log(`Run ${c.cyan("npx claude-setup sync")} to capture the current state as a new node.`);
+}