claude-setup 1.1.1 → 1.1.2

package/dist/commands/status.js

@@ -1,23 +1,135 @@
 import { readManifest } from "../manifest.js";
 import { readState } from "../state.js";
+import { detectOS } from "../os.js";
+import { c, statusLine, section } from "../output.js";
+function safeJsonParse(content) {
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
 export async function runStatus() {
     const manifest = await readManifest();
     const state = await readState();
+    const os = detectOS();
     if (!manifest) {
-        console.log("No setup found.\n  Run: npx claude-setup init");
+        console.log(`${c.yellow("⚠️  No setup found.")}\n  Run: ${c.cyan("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):`);
+    const version = last.claudeStackVersion ?? "unknown";
+    // --- 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}`);
+    // --- Setup files ---
+    section("Setup files");
+    // CLAUDE.md
+    if (state.claudeMd.exists) {
+        statusLine("✅", "CLAUDE.md", "exists");
+    }
+    else {
+        statusLine("❌", "CLAUDE.md", "missing");
+    }
+    // .mcp.json
+    if (state.mcpJson.exists && state.mcpJson.content) {
+        const mcp = safeJsonParse(state.mcpJson.content);
+        const serverCount = mcp?.mcpServers
+            ? Object.keys(mcp.mcpServers).length
+            : 0;
+        statusLine("✅", ".mcp.json", `${serverCount} server(s)`);
+    }
+    else {
+        statusLine("❌", ".mcp.json", "missing");
+    }
+    // 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;
+            }
+        }
+        statusLine("✅", "settings.json", `${hookCount} hook(s)`);
+    }
+    else {
+        statusLine("❌", "settings.json", "missing");
+    }
+    // Lists
+    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"}`);
+    // --- Run history ---
+    section("Run history (last 5)");
     for (const r of manifest.runs.slice(-5)) {
-        console.log(`  ${r.at}  ${r.command}${r.input ? ` — "${r.input}"` : ""}`);
+        const inputStr = r.input ? ` — "${r.input}"` : "";
+        console.log(`  ${c.dim(r.at)}  ${r.command}${inputStr}`);
+    }
+    // --- Health hint ---
+    const hint = getHealthHint(manifest, state);
+    if (hint) {
+        section("Health hint");
+        console.log(`  ${hint}`);
     }
-    console.log("\n  npx claude-setup sync    — update after changes");
-    console.log("  npx claude-setup doctor  — validate environment");
+    // --- Next action ---
+    const next = getNextAction(manifest, state);
+    if (next) {
+        section("Next action");
+        console.log(`  ${next}`);
+    }
+    console.log("");
+}
+function inferProjectType(state) {
+    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";
+        if (content.includes("python"))
+            return "Python";
+        if (content.includes("go ") || content.includes("golang"))
+            return "Go";
+        if (content.includes("rust"))
+            return "Rust";
+        if (content.includes("ruby"))
+            return "Ruby";
+        if (content.includes("java") && !content.includes("javascript"))
+            return "Java";
+    }
+    return c.dim("unknown — run init to detect");
+}
+function getHealthHint(manifest, _state) {
+    const last = manifest.runs.at(-1);
+    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;
+        if (deletionCount > 0) {
+            return `${c.red("🔴")}  Last sync detected ${deletionCount} deletion(s). Verify setup is still valid.`;
+        }
+    }
+    if (daysSince > 7) {
+        return `${c.yellow("⚠️")}  ${daysSince} day(s) since last sync. Source files may have drifted.`;
+    }
+    return `${c.green("✅")} Setup looks current.`;
+}
+function getNextAction(manifest, _state) {
+    const last = manifest.runs.at(-1);
+    if (!last)
+        return `Run ${c.cyan("npx claude-setup init")} to set up your project.`;
+    const daysSince = Math.floor((Date.now() - new Date(last.at).getTime()) / (1000 * 60 * 60 * 24));
+    if (daysSince > 7)
+        return `Run ${c.cyan("npx claude-setup sync")} to check for changes.`;
+    return null;
 }

package/dist/commands/sync.d.ts

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

package/dist/commands/sync.js

@@ -3,6 +3,7 @@ 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";
 function ensureDir(dir) {
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
@@ -21,6 +22,9 @@ function computeDiff(snapshot, collected) {
     const changed = [];
     const deleted = [];
     for (const [path, content] of Object.entries(current)) {
+        // Skip virtual keys — they're not real files
+        if (path === "__digest__")
+            continue;
         const hash = sha256(content);
         if (!snapshot[path]) {
             added.push({ path, content: truncate(content, 2000) });
@@ -30,34 +34,58 @@ function computeDiff(snapshot, collected) {
         }
     }
     for (const path of Object.keys(snapshot)) {
+        // Skip virtual keys
+        if (path === "__digest__")
+            continue;
         if (!current[path])
             deleted.push(path);
     }
     return { added, changed, deleted };
 }
-export async function runSync() {
+export async function runSync(opts = {}) {
+    const dryRun = opts.dryRun ?? false;
     const manifest = await readManifest();
     if (!manifest?.runs.length) {
-        console.log("No previous run found. Start with: npx claude-setup init");
+        console.log(`No previous run found. Start with: ${c.cyan("npx claude-setup init")}`);
         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) {
-        console.log(`✅ No changes since ${lastRun.at}. Setup is current.`);
+        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);
+    if (dryRun) {
+        console.log(c.bold("[DRY RUN] Changes detected:\n"));
+        if (diff.added.length) {
+            console.log(c.green(`  +${diff.added.length} added`));
+            for (const f of diff.added)
+                console.log(`    ${f.path}`);
+        }
+        if (diff.changed.length) {
+            console.log(c.yellow(`  ~${diff.changed.length} modified`));
+            for (const f of diff.changed)
+                console.log(`    ${f.path}`);
+        }
+        if (diff.deleted.length) {
+            console.log(c.red(`  -${diff.deleted.length} deleted`));
+            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)`);
+        return;
+    }
     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
+Changes since ${c.dim(lastRun.at)}:
+  ${c.green(`+${diff.added.length}`)} added  ${c.yellow(`~${diff.changed.length}`)} modified  ${c.red(`-${diff.deleted.length}`)} deleted
 
-✅ Ready. Open Claude Code and run:
-   /stack-sync
+${c.green("✅")} Ready. Open Claude Code and run:
+   ${c.cyan("/stack-sync")}
   `);
 }

package/dist/config.d.ts

@@ -1,3 +1,8 @@
+export interface TruncationRule {
+    maxLines?: number;
+    metadataOnly?: boolean;
+    maxBytes?: number;
+}
 export interface SetupConfig {
     maxSourceFiles: number;
     maxDepth: number;
@@ -11,5 +16,14 @@ export interface SetupConfig {
     digestMode: boolean;
     extraBlockedDirs: string[];
     sourceDirs: string[];
+    truncationRules: Record<string, TruncationRule>;
 }
 export declare function loadConfig(cwd?: string): SetupConfig;
+/**
+ * Auto-generate .claude-setup.json with sensible defaults.
+ * Only creates if it doesn't exist — never overwrites.
+ * Returns true if created, false if already existed.
+ */
+export declare function ensureConfig(cwd?: string): boolean;
+/** Apply truncation rule to file content */
+export declare function applyTruncation(filename: string, content: string, config: SetupConfig): string;

package/dist/config.js

@@ -1,5 +1,18 @@
-import { readFileSync, existsSync } from "fs";
+import { readFileSync, writeFileSync, existsSync } from "fs";
 import { join } from "path";
+// --- Defaults ---
+// Sensible for projects up to ~200 source files.
+// For bigger projects, the developer can increase budgets in .claude-setup.json.
+const DEFAULT_TRUNCATION_RULES = {
+    "package-lock.json": { metadataOnly: true },
+    "Dockerfile": { maxLines: 50 },
+    "docker-compose.yml": { maxLines: 100, maxBytes: 8000 },
+    "docker-compose.yaml": { maxLines: 100, maxBytes: 8000 },
+    "pom.xml": { maxLines: 80 },
+    "build.gradle": { maxLines: 80 },
+    "build.gradle.kts": { maxLines: 80 },
+    "setup.py": { maxLines: 60 },
+};
 const DEFAULTS = {
     maxSourceFiles: 15,
     maxDepth: 6,
@@ -13,14 +26,21 @@ const DEFAULTS = {
     digestMode: true,
     extraBlockedDirs: [],
     sourceDirs: [],
+    truncationRules: DEFAULT_TRUNCATION_RULES,
 };
 const CONFIG_FILENAME = ".claude-setup.json";
 export function loadConfig(cwd = process.cwd()) {
     const configPath = join(cwd, CONFIG_FILENAME);
     if (!existsSync(configPath))
-        return { ...DEFAULTS };
+        return { ...DEFAULTS, truncationRules: { ...DEFAULT_TRUNCATION_RULES } };
     try {
         const raw = JSON.parse(readFileSync(configPath, "utf8"));
+        // Merge truncation rules: user overrides win, defaults fill gaps
+        const userRules = raw.truncationRules ?? {};
+        const mergedRules = { ...DEFAULT_TRUNCATION_RULES };
+        for (const [file, rule] of Object.entries(userRules)) {
+            mergedRules[file] = rule;
+        }
         return {
             maxSourceFiles: raw.maxSourceFiles ?? DEFAULTS.maxSourceFiles,
             maxDepth: raw.maxDepth ?? DEFAULTS.maxDepth,
@@ -34,9 +54,75 @@ export function loadConfig(cwd = process.cwd()) {
             digestMode: raw.digestMode ?? DEFAULTS.digestMode,
             extraBlockedDirs: raw.extraBlockedDirs ?? DEFAULTS.extraBlockedDirs,
             sourceDirs: raw.sourceDirs ?? DEFAULTS.sourceDirs,
+            truncationRules: mergedRules,
         };
     }
     catch {
-        return { ...DEFAULTS };
+        return { ...DEFAULTS, truncationRules: { ...DEFAULT_TRUNCATION_RULES } };
+    }
+}
+/**
+ * Auto-generate .claude-setup.json with sensible defaults.
+ * Only creates if it doesn't exist — never overwrites.
+ * Returns true if created, false if already existed.
+ */
+export function ensureConfig(cwd = process.cwd()) {
+    const configPath = join(cwd, CONFIG_FILENAME);
+    if (existsSync(configPath))
+        return false;
+    const config = {
+        maxSourceFiles: DEFAULTS.maxSourceFiles,
+        maxDepth: DEFAULTS.maxDepth,
+        maxFileSizeKB: DEFAULTS.maxFileSizeKB,
+        tokenBudget: DEFAULTS.tokenBudget,
+        digestMode: DEFAULTS.digestMode,
+        extraBlockedDirs: DEFAULTS.extraBlockedDirs,
+        sourceDirs: DEFAULTS.sourceDirs,
+        truncationRules: DEFAULT_TRUNCATION_RULES,
+    };
+    try {
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Apply truncation rule to file content */
+export function applyTruncation(filename, content, config) {
+    const rule = config.truncationRules[filename];
+    if (!rule) {
+        // No rule — use generic cap
+        return content.length > 4000 ? content.slice(0, 4000) + "\n[... truncated]" : content;
+    }
+    // Metadata-only extraction (e.g. package-lock.json)
+    if (rule.metadataOnly) {
+        try {
+            const parsed = JSON.parse(content);
+            return JSON.stringify({
+                name: parsed.name,
+                version: parsed.version,
+                lockfileVersion: parsed.lockfileVersion,
+            }, null, 2);
+        }
+        catch {
+            return `[${filename}: could not parse]`;
+        }
+    }
+    // maxBytes check first: if file is small enough, content passes through before line truncation
+    if (rule.maxBytes && content.length <= rule.maxBytes) {
+        return content;
+    }
+    // Line-based truncation
+    if (rule.maxLines) {
+        const lines = content.split("\n");
+        if (lines.length <= rule.maxLines)
+            return content;
+        return lines.slice(0, rule.maxLines).join("\n") + `\n[... ${lines.length - rule.maxLines} more lines truncated]`;
+    }
+    // Byte cap
+    if (rule.maxBytes && content.length > rule.maxBytes) {
+        return content.slice(0, rule.maxBytes) + "\n[... truncated]";
     }
+    return content;
 }

package/dist/doctor.d.ts

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