claude-setup 1.0.0

package/dist/commands/add.js

@@ -0,0 +1,49 @@
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { createInterface } from "readline";
+import { collectProjectFiles } from "../collect.js";
+import { readState } from "../state.js";
+import { updateManifest } from "../manifest.js";
+import { buildAddCommand } from "../builder.js";
+function ensureDir(dir) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+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());
+        });
+    });
+}
+// Conservative — only redirect when unambiguously single-file
+function isSingleFileOperation(input) {
+    return (/to \.mcp\.json\s*$/i.test(input) ||
+        /to settings\.json\s*$/i.test(input) ||
+        /to claude\.md\s*$/i.test(input));
+}
+export async function runAdd() {
+    const userInput = await promptFreeText("What do you want to add to your Claude Code setup?");
+    if (!userInput) {
+        console.log("No input provided.");
+        return;
+    }
+    if (isSingleFileOperation(userInput)) {
+        console.log(`
+For single changes, Claude Code is faster:
+  Just tell it: "${userInput}"
+
+Use claude-setup add when the change spans multiple files —
+capabilities that need documentation, MCP servers, skills, and hooks together.
+    `);
+        return;
+    }
+    const state = await readState();
+    const collected = await collectProjectFiles();
+    const content = buildAddCommand(userInput, collected, state);
+    ensureDir(".claude/commands");
+    writeFileSync(".claude/commands/stack-add.md", content, "utf8");
+    await updateManifest("add", collected, { input: userInput });
+    console.log(`\n✅ Ready. Open Claude Code and run:\n   /stack-add\n`);
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1 @@
+export { runDoctor } from "../doctor.js";

package/dist/commands/doctor.js

@@ -0,0 +1 @@
+export { runDoctor } from "../doctor.js";

package/dist/commands/init.d.ts

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

package/dist/commands/init.js

@@ -0,0 +1,42 @@
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { collectProjectFiles, isEmptyProject } from "../collect.js";
+import { readState } from "../state.js";
+import { updateManifest } from "../manifest.js";
+import { buildEmptyProjectCommand, buildAtomicSteps, buildOrchestratorCommand, } from "../builder.js";
+function ensureDir(dir) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+export async function runInit() {
+    const state = await readState();
+    const collected = await collectProjectFiles();
+    ensureDir(".claude/commands");
+    if (isEmptyProject(collected)) {
+        const content = buildEmptyProjectCommand();
+        writeFileSync(".claude/commands/stack-init.md", content, "utf8");
+        await updateManifest("init", collected);
+        console.log(`
+✅ New project detected.
+
+Open Claude Code and run:
+   /stack-init
+
+Claude Code will ask 3 questions, then set up your environment.
+    `);
+        return;
+    }
+    // Standard init — 6 atomic steps + orchestrator
+    const steps = buildAtomicSteps(collected, state);
+    for (const step of steps) {
+        writeFileSync(join(".claude/commands", step.filename), step.content, "utf8");
+    }
+    writeFileSync(".claude/commands/stack-init.md", buildOrchestratorCommand(steps), "utf8");
+    await updateManifest("init", collected);
+    console.log(`
+✅ Ready. Open Claude Code and run:
+   /stack-init
+
+Runs 6 atomic steps. If one fails, re-run only that step.
+  `);
+}

package/dist/commands/remove.d.ts

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

package/dist/commands/remove.js

@@ -0,0 +1,33 @@
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { createInterface } from "readline";
+import { collectProjectFiles } from "../collect.js";
+import { readState } from "../state.js";
+import { updateManifest } from "../manifest.js";
+import { buildRemoveCommand } from "../builder.js";
+function ensureDir(dir) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+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 runRemove() {
+    const userInput = await promptFreeText("What do you want to remove from your Claude Code setup?");
+    if (!userInput) {
+        console.log("No input provided.");
+        return;
+    }
+    const state = await readState();
+    const collected = await collectProjectFiles();
+    const content = buildRemoveCommand(userInput, state);
+    ensureDir(".claude/commands");
+    writeFileSync(".claude/commands/stack-remove.md", content, "utf8");
+    await updateManifest("remove", collected, { input: userInput });
+    console.log(`\n✅ Ready. Open Claude Code and run:\n   /stack-remove\n`);
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,23 @@
+import { readManifest } from "../manifest.js";
+import { readState } from "../state.js";
+export async function runStatus() {
+    const manifest = await readManifest();
+    const state = await readState();
+    if (!manifest) {
+        console.log("No setup found.\n  Run: npx claude-setup init");
+        return;
+    }
+    const last = manifest.runs.at(-1);
+    console.log(`Last: ${last.command} at ${last.at} (v${last.claudeStackVersion})\n`);
+    console.log(`CLAUDE.md             ${state.claudeMd.exists ? "✅" : "❌ missing"}`);
+    console.log(`.mcp.json             ${state.mcpJson.exists ? "✅" : "❌ missing"}`);
+    console.log(`settings.json         ${state.settings.exists ? "✅" : "❌ missing"}`);
+    console.log(`Skills                ${state.skills.length || "none"}`);
+    console.log(`Workflows             ${state.workflows.length || "none"}`);
+    console.log(`\nHistory (last 5):`);
+    for (const r of manifest.runs.slice(-5)) {
+        console.log(`  ${r.at}  ${r.command}${r.input ? ` — "${r.input}"` : ""}`);
+    }
+    console.log("\n  npx claude-setup sync    — update after changes");
+    console.log("  npx claude-setup doctor  — validate environment");
+}

package/dist/commands/sync.d.ts

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

package/dist/commands/sync.js

@@ -0,0 +1,63 @@
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { collectProjectFiles } from "../collect.js";
+import { readState } from "../state.js";
+import { readManifest, sha256, updateManifest } from "../manifest.js";
+import { buildSyncCommand } from "../builder.js";
+function ensureDir(dir) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+function truncate(content, maxChars) {
+    if (content.length <= maxChars)
+        return content;
+    return content.slice(0, maxChars) + "\n[... truncated for sync diff]";
+}
+function computeDiff(snapshot, collected) {
+    const current = {
+        ...collected.configs,
+        ...Object.fromEntries(collected.source.map(f => [f.path, f.content])),
+    };
+    const added = [];
+    const changed = [];
+    const deleted = [];
+    for (const [path, content] of Object.entries(current)) {
+        const hash = sha256(content);
+        if (!snapshot[path]) {
+            added.push({ path, content: truncate(content, 2000) });
+        }
+        else if (snapshot[path] !== hash) {
+            changed.push({ path, current: truncate(content, 2000) });
+        }
+    }
+    for (const path of Object.keys(snapshot)) {
+        if (!current[path])
+            deleted.push(path);
+    }
+    return { added, changed, deleted };
+}
+export async function runSync() {
+    const manifest = await readManifest();
+    if (!manifest?.runs.length) {
+        console.log("No previous run found. Start with: npx claude-setup init");
+        return;
+    }
+    const lastRun = manifest.runs.at(-1);
+    const collected = await collectProjectFiles();
+    const diff = computeDiff(lastRun.snapshot, collected);
+    if (!diff.added.length && !diff.changed.length && !diff.deleted.length) {
+        console.log(`✅ No changes since ${lastRun.at}. Setup is current.`);
+        return;
+    }
+    const state = await readState();
+    const content = buildSyncCommand(diff, collected, state);
+    ensureDir(".claude/commands");
+    writeFileSync(".claude/commands/stack-sync.md", content, "utf8");
+    await updateManifest("sync", collected);
+    console.log(`
+Changes since ${lastRun.at}:
+  +${diff.added.length} added  ~${diff.changed.length} modified  -${diff.deleted.length} deleted
+
+✅ Ready. Open Claude Code and run:
+   /stack-sync
+  `);
+}

package/dist/doctor.d.ts

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

package/dist/doctor.js

@@ -0,0 +1,72 @@
+import { existsSync, readFileSync } from "fs";
+import { execSync } from "child_process";
+import { readManifest } from "./manifest.js";
+import { readState } from "./state.js";
+function tryExec(cmd) {
+    try {
+        return execSync(cmd, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+    }
+    catch {
+        return null;
+    }
+}
+function readIfExists(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        return readFileSync(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function line(icon, label, detail) {
+    console.log(`  ${icon} ${label}${detail ? ` — ${detail}` : ""}`);
+}
+export async function runDoctor() {
+    const manifest = await readManifest();
+    const state = await readState();
+    console.log("claude-setup doctor\n");
+    // Claude Code installed?
+    const cv = tryExec("claude --version");
+    line(cv ? "✅" : "❌", "Claude Code", cv?.trim() ?? "not found");
+    // Manifest?
+    const lastRun = manifest?.runs.at(-1);
+    line(manifest ? "✅" : "⚠️ ", ".claude/claude-setup.json", manifest ? `last: ${lastRun?.command} at ${lastRun?.at}` : "not found — run: npx claude-setup init");
+    // Files from last run still on disk?
+    if (lastRun?.filesRead.length) {
+        console.log("\nFiles from last run (sample):");
+        for (const f of lastRun.filesRead.slice(0, 8)) {
+            line(existsSync(f) ? "✅" : "⚠️ ", f, existsSync(f) ? "" : "not found on disk");
+        }
+    }
+    // Env vars in .mcp.json present in env template?
+    if (state.mcpJson.content) {
+        const refs = [...state.mcpJson.content.matchAll(/\$\{?([A-Z_][A-Z0-9_]+)\}?/g)]
+            .map(m => m[1]);
+        const unique = [...new Set(refs)];
+        if (unique.length) {
+            const template = readIfExists(".env.example") ?? readIfExists(".env.sample") ?? "";
+            console.log("\nMCP environment variables:");
+            for (const v of unique) {
+                line(template.includes(v) ? "✅" : "⚠️ ", v, template.includes(v) ? "found in env template" : "missing from .env.example");
+            }
+        }
+    }
+    // Workflow secrets
+    if (state.workflows.length) {
+        const secrets = new Set();
+        for (const wf of state.workflows) {
+            const content = readIfExists(wf) ?? "";
+            for (const m of content.matchAll(/\$\{\{\s*secrets\.([A-Z_]+)\s*\}\}/g)) {
+                secrets.add(m[1]);
+            }
+        }
+        if (secrets.size) {
+            console.log("\nWorkflow secrets (add to GitHub Settings → Secrets):");
+            for (const s of secrets)
+                console.log(`  ⚠️  ${s}`);
+        }
+    }
+    console.log("\n✅ Done.");
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { createRequire } from "module";
+import { runInit } from "./commands/init.js";
+import { runAdd } from "./commands/add.js";
+import { runSync } from "./commands/sync.js";
+import { runStatus } from "./commands/status.js";
+import { runDoctor } from "./commands/doctor.js";
+import { runRemove } from "./commands/remove.js";
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+const program = new Command();
+program
+    .name("claude-setup")
+    .description("Setup layer for Claude Code")
+    .version(pkg.version);
+program.command("init").description("Full project setup — new or existing").action(runInit);
+program.command("add").description("Add a multi-file capability").action(runAdd);
+program.command("sync").description("Update setup after project changes").action(runSync);
+program.command("status").description("Show current setup (instant)").action(runStatus);
+program.command("doctor").description("Validate environment").action(runDoctor);
+program.command("remove").description("Remove a capability cleanly").action(runRemove);
+program.action(runInit);
+program.parse();

package/dist/manifest.d.ts

@@ -0,0 +1,20 @@
+import { CollectedFiles } from "./collect.js";
+export interface ManifestRun {
+    command: string;
+    at: string;
+    claudeStackVersion: string;
+    input?: string;
+    filesRead: string[];
+    snapshot: Record<string, string>;
+}
+export interface Manifest {
+    version: string;
+    created: string;
+    runs: ManifestRun[];
+}
+export declare function sha256(content: string): string;
+export declare function readManifest(cwd?: string): Promise<Manifest | null>;
+export declare function updateManifest(command: string, collected: CollectedFiles, opts?: {
+    input?: string;
+    cwd?: string;
+}): Promise<void>;

package/dist/manifest.js

@@ -0,0 +1,84 @@
+import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { createHash } from "crypto";
+const MANIFEST_FILENAME = ".claude/claude-setup.json";
+export function sha256(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+export async function readManifest(cwd = process.cwd()) {
+    const filePath = join(cwd, MANIFEST_FILENAME);
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const raw = readFileSync(filePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        // Corrupted — back it up and start fresh
+        const backupPath = filePath + ".bak";
+        try {
+            renameSync(filePath, backupPath);
+            console.warn(`⚠️  Manifest was corrupted. Backed up to ${backupPath}`);
+        }
+        catch {
+            console.warn(`⚠️  Manifest was corrupted and could not be backed up.`);
+        }
+        return null;
+    }
+}
+export async function updateManifest(command, collected, opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const filePath = join(cwd, MANIFEST_FILENAME);
+    // Read version from package.json
+    let version = "0.0.0";
+    try {
+        const pkgPath = join(dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1")), "..", "package.json");
+        if (existsSync(pkgPath)) {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+            version = pkg.version ?? "0.0.0";
+        }
+    }
+    catch { /* use default */ }
+    // Build snapshot — hash of every file we read
+    const snapshot = {};
+    for (const [path, content] of Object.entries(collected.configs)) {
+        snapshot[path] = sha256(content);
+    }
+    for (const { path, content } of collected.source) {
+        snapshot[path] = sha256(content);
+    }
+    const filesRead = [
+        ...Object.keys(collected.configs),
+        ...collected.source.map(s => s.path),
+    ];
+    const run = {
+        command,
+        at: new Date().toISOString(),
+        claudeStackVersion: version,
+        ...(opts.input ? { input: opts.input } : {}),
+        filesRead,
+        snapshot,
+    };
+    let manifest;
+    const existing = await readManifest(cwd);
+    if (existing) {
+        existing.runs.push(run);
+        manifest = existing;
+    }
+    else {
+        manifest = {
+            version: "1",
+            created: new Date().toISOString(),
+            runs: [run],
+        };
+    }
+    try {
+        const dir = dirname(filePath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(filePath, JSON.stringify(manifest, null, 2), "utf8");
+    }
+    catch (err) {
+        console.warn(`⚠️  Could not write manifest to ${filePath}: ${err}`);
+    }
+}

package/dist/state.d.ts

@@ -0,0 +1,24 @@
+import { Manifest } from "./manifest.js";
+export interface ExistingState {
+    claudeMd: {
+        exists: boolean;
+        content?: string;
+    };
+    mcpJson: {
+        exists: boolean;
+        content?: string;
+    };
+    settings: {
+        exists: boolean;
+        content?: string;
+    };
+    skills: string[];
+    commands: string[];
+    workflows: string[];
+    hasGithubDir: boolean;
+    hasDotClaude: boolean;
+    manifest: Manifest | null;
+}
+export declare function readState(cwd?: string): Promise<ExistingState>;
+declare function readIfExists(filePath: string): string | null;
+export { readIfExists };

package/dist/state.js

@@ -0,0 +1,55 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { glob } from "glob";
+import { readManifest } from "./manifest.js";
+export async function readState(cwd = process.cwd()) {
+    const claudeMdPath = join(cwd, "CLAUDE.md");
+    const mcpJsonPath = join(cwd, ".mcp.json");
+    const settingsPath = join(cwd, ".claude", "settings.json");
+    const claudeMd = readIfExists(claudeMdPath);
+    const mcpJson = readIfExists(mcpJsonPath);
+    const settings = readIfExists(settingsPath);
+    let skills = [];
+    try {
+        skills = await glob(".claude/skills/*/SKILL.md", { cwd, posix: true });
+    }
+    catch { /* no skills */ }
+    let commands = [];
+    try {
+        const allCmds = await glob(".claude/commands/*.md", { cwd, posix: true });
+        commands = allCmds.filter(c => !c.includes("stack-"));
+    }
+    catch { /* no commands */ }
+    let workflows = [];
+    try {
+        workflows = await glob(".github/workflows/*.yml", { cwd, posix: true });
+        const yamlWorkflows = await glob(".github/workflows/*.yaml", { cwd, posix: true });
+        workflows = [...workflows, ...yamlWorkflows];
+    }
+    catch { /* no workflows */ }
+    const hasGithubDir = existsSync(join(cwd, ".github"));
+    const hasDotClaude = existsSync(join(cwd, ".claude"));
+    const manifest = await readManifest(cwd);
+    return {
+        claudeMd: { exists: claudeMd !== null, content: claudeMd ?? undefined },
+        mcpJson: { exists: mcpJson !== null, content: mcpJson ?? undefined },
+        settings: { exists: settings !== null, content: settings ?? undefined },
+        skills,
+        commands,
+        workflows,
+        hasGithubDir,
+        hasDotClaude,
+        manifest,
+    };
+}
+function readIfExists(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        return readFileSync(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+export { readIfExists };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "claude-setup",
+  "version": "1.0.0",
+  "description": "Setup layer for Claude Code — reads your project, writes command files, Claude Code does the rest",
+  "type": "module",
+  "bin": {
+    "claude-setup": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "tsc"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "cli",
+    "developer-tools",
+    "ai",
+    "anthropic",
+    "automation",
+    "scaffolding",
+    "project-setup",
+    "mcp",
+    "npx"
+  ],
+  "author": "AbdoKnbGit",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AbdoKnbGit/claude-setup.git"
+  },
+  "homepage": "https://github.com/AbdoKnbGit/claude-setup#readme",
+  "bugs": {
+    "url": "https://github.com/AbdoKnbGit/claude-setup/issues"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "glob": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  }
+}

package/templates/add.md

@@ -0,0 +1,64 @@
+<!-- Generated by claude-setup add — {{DATE}} -->
+<!-- Run /stack-add in Claude Code -->
+
+The developer wants to add this to their Claude Code setup:
+"{{USER_INPUT}}"
+
+---
+
+## Project context
+
+{{CONFIG_FILES}}
+
+{{SOURCE_FILES}}
+
+---
+
+## Current setup — read before writing anything
+
+{{#if HAS_CLAUDE_MD}}
+### CLAUDE.md
+{{CLAUDE_MD_CONTENT}}
+{{/if}}
+
+{{#if HAS_MCP_JSON}}
+### .mcp.json
+{{MCP_JSON_CONTENT}}
+{{/if}}
+
+{{#if HAS_SETTINGS}}
+### .claude/settings.json
+{{SETTINGS_CONTENT}}
+{{/if}}
+
+Skills installed:   {{SKILLS_LIST}}
+Commands installed: {{COMMANDS_LIST}}
+
+---
+
+## Your job
+
+Figure out which files need to change to fulfill the request.
+Adding a capability to Claude Code is rarely one file — it usually means touching
+CLAUDE.md, possibly an MCP entry, possibly a skill, possibly a hook.
+
+For every file you touch:
+- Read its current content above first
+- Merge and append only
+- Do not duplicate what already exists
+- Extend existing files rather than creating parallel ones
+
+If the request mentions something not evidenced in the project files: say so and ask
+whether they want to add it generically or need to add the underlying service first.
+
+---
+
+## Output format — strict
+
+Updated:
+  ✅ [path] — [what changed and why]
+
+Skipped:
+  ⏭  [path] — [why not needed for this request]
+
+One line per file. Nothing else.