@caliber-ai/cli 0.20.2 → 0.21.1

package/dist/bin.js

@@ -84,7 +84,7 @@ import chalk3 from "chalk";
 import ora2 from "ora";
 import readline from "readline";
 import select from "@inquirer/select";
-import fs18 from "fs";
+import fs17 from "fs";
 
 // src/auth/token-store.ts
 init_constants();
@@ -1115,219 +1115,77 @@ async function enrichFingerprintWithLLM(fingerprint, dir) {
   }
 }
 
-// src/scanner/index.ts
-import fs9 from "fs";
-import path10 from "path";
-import crypto3 from "crypto";
-function scanLocalState(dir) {
-  const items = [];
-  const claudeMdPath = path10.join(dir, "CLAUDE.md");
-  if (fs9.existsSync(claudeMdPath)) {
-    items.push({
-      type: "rule",
-      platform: "claude",
-      name: "CLAUDE.md",
-      contentHash: hashFile(claudeMdPath),
-      path: claudeMdPath
-    });
-  }
-  const skillsDir = path10.join(dir, ".claude", "skills");
-  if (fs9.existsSync(skillsDir)) {
-    for (const file of fs9.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path10.join(skillsDir, file);
-      items.push({
-        type: "skill",
-        platform: "claude",
-        name: file,
-        contentHash: hashFile(filePath),
-        path: filePath
-      });
-    }
-  }
-  const mcpJsonPath = path10.join(dir, ".mcp.json");
-  if (fs9.existsSync(mcpJsonPath)) {
-    try {
-      const mcpJson = JSON.parse(fs9.readFileSync(mcpJsonPath, "utf-8"));
-      if (mcpJson.mcpServers) {
-        for (const name of Object.keys(mcpJson.mcpServers)) {
-          items.push({
-            type: "mcp",
-            platform: "claude",
-            name,
-            contentHash: hashJson(mcpJson.mcpServers[name]),
-            path: mcpJsonPath
-          });
-        }
-      }
-    } catch {
-    }
-  }
-  const cursorrulesPath = path10.join(dir, ".cursorrules");
-  if (fs9.existsSync(cursorrulesPath)) {
-    items.push({
-      type: "rule",
-      platform: "cursor",
-      name: ".cursorrules",
-      contentHash: hashFile(cursorrulesPath),
-      path: cursorrulesPath
-    });
-  }
-  const cursorRulesDir = path10.join(dir, ".cursor", "rules");
-  if (fs9.existsSync(cursorRulesDir)) {
-    for (const file of fs9.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path10.join(cursorRulesDir, file);
-      items.push({
-        type: "rule",
-        platform: "cursor",
-        name: file,
-        contentHash: hashFile(filePath),
-        path: filePath
-      });
-    }
-  }
-  const cursorSkillsDir = path10.join(dir, ".cursor", "skills");
-  if (fs9.existsSync(cursorSkillsDir)) {
-    try {
-      for (const slug of fs9.readdirSync(cursorSkillsDir)) {
-        const skillFile = path10.join(cursorSkillsDir, slug, "SKILL.md");
-        if (fs9.existsSync(skillFile)) {
-          items.push({
-            type: "skill",
-            platform: "cursor",
-            name: `${slug}/SKILL.md`,
-            contentHash: hashFile(skillFile),
-            path: skillFile
-          });
-        }
-      }
-    } catch {
-    }
-  }
-  const cursorMcpPath = path10.join(dir, ".cursor", "mcp.json");
-  if (fs9.existsSync(cursorMcpPath)) {
-    try {
-      const mcpJson = JSON.parse(fs9.readFileSync(cursorMcpPath, "utf-8"));
-      if (mcpJson.mcpServers) {
-        for (const name of Object.keys(mcpJson.mcpServers)) {
-          items.push({
-            type: "mcp",
-            platform: "cursor",
-            name,
-            contentHash: hashJson(mcpJson.mcpServers[name]),
-            path: cursorMcpPath
-          });
-        }
-      }
-    } catch {
-    }
-  }
-  return items;
-}
-function compareState(serverItems, localItems) {
-  const installed = [];
-  const missing = [];
-  const outdated = [];
-  const extra = [];
-  const localMap = /* @__PURE__ */ new Map();
-  for (const item of localItems) {
-    localMap.set(`${item.type}:${item.platform}:${item.name}`, item);
-  }
-  for (const server of serverItems) {
-    const key = `${server.type}:${server.platform}:${server.name}`;
-    const local = localMap.get(key);
-    localMap.delete(key);
-    if (!local) {
-      missing.push(server);
-    } else if (local.contentHash !== server.content_hash) {
-      outdated.push({ server, local });
-    } else {
-      installed.push({ server, local });
-    }
-  }
-  for (const local of localMap.values()) {
-    extra.push(local);
-  }
-  return { installed, missing, outdated, extra };
-}
-function hashFile(filePath) {
-  const text = fs9.readFileSync(filePath, "utf-8");
-  return crypto3.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
-}
-function hashJson(obj) {
-  return crypto3.createHash("sha256").update(JSON.stringify(obj)).digest("hex");
-}
-
 // src/writers/index.ts
-import fs14 from "fs";
+import fs13 from "fs";
 
 // src/writers/claude/index.ts
-import fs10 from "fs";
-import path11 from "path";
+import fs9 from "fs";
+import path10 from "path";
 function writeClaudeConfig(config) {
   const written = [];
-  fs10.writeFileSync("CLAUDE.md", config.claudeMd);
+  fs9.writeFileSync("CLAUDE.md", config.claudeMd);
   written.push("CLAUDE.md");
   if (config.skills?.length) {
-    const skillsDir = path11.join(".claude", "skills");
-    if (!fs10.existsSync(skillsDir)) fs10.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path10.join(".claude", "skills");
+    if (!fs9.existsSync(skillsDir)) fs9.mkdirSync(skillsDir, { recursive: true });
     for (const skill of config.skills) {
       const filename = `${skill.name.replace(/[^a-z0-9-]/gi, "-").toLowerCase()}.md`;
-      const skillPath = path11.join(skillsDir, filename);
-      fs10.writeFileSync(skillPath, skill.content);
+      const skillPath = path10.join(skillsDir, filename);
+      fs9.writeFileSync(skillPath, skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     let existingServers = {};
     try {
-      if (fs10.existsSync(".mcp.json")) {
-        const existing = JSON.parse(fs10.readFileSync(".mcp.json", "utf-8"));
+      if (fs9.existsSync(".mcp.json")) {
+        const existing = JSON.parse(fs9.readFileSync(".mcp.json", "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs10.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs9.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(".mcp.json");
   }
   return written;
 }
 
 // src/writers/cursor/index.ts
-import fs11 from "fs";
-import path12 from "path";
+import fs10 from "fs";
+import path11 from "path";
 function writeCursorConfig(config) {
   const written = [];
   if (config.cursorrules) {
-    fs11.writeFileSync(".cursorrules", config.cursorrules);
+    fs10.writeFileSync(".cursorrules", config.cursorrules);
     written.push(".cursorrules");
   }
   if (config.rules?.length) {
-    const rulesDir = path12.join(".cursor", "rules");
-    if (!fs11.existsSync(rulesDir)) fs11.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path11.join(".cursor", "rules");
+    if (!fs10.existsSync(rulesDir)) fs10.mkdirSync(rulesDir, { recursive: true });
     for (const rule of config.rules) {
-      const rulePath = path12.join(rulesDir, rule.filename);
-      fs11.writeFileSync(rulePath, rule.content);
+      const rulePath = path11.join(rulesDir, rule.filename);
+      fs10.writeFileSync(rulePath, rule.content);
       written.push(rulePath);
     }
   }
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path12.join(".cursor", "skills", skill.slug);
-      if (!fs11.existsSync(skillDir)) fs11.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path12.join(skillDir, "SKILL.md");
-      fs11.writeFileSync(skillPath, skill.content);
+      const skillDir = path11.join(".cursor", "skills", skill.slug);
+      if (!fs10.existsSync(skillDir)) fs10.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path11.join(skillDir, "SKILL.md");
+      fs10.writeFileSync(skillPath, skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     const cursorDir = ".cursor";
-    if (!fs11.existsSync(cursorDir)) fs11.mkdirSync(cursorDir, { recursive: true });
-    const mcpPath = path12.join(cursorDir, "mcp.json");
+    if (!fs10.existsSync(cursorDir)) fs10.mkdirSync(cursorDir, { recursive: true });
+    const mcpPath = path11.join(cursorDir, "mcp.json");
     let existingServers = {};
     try {
-      if (fs11.existsSync(mcpPath)) {
-        const existing = JSON.parse(fs11.readFileSync(mcpPath, "utf-8"));
+      if (fs10.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs10.readFileSync(mcpPath, "utf-8"));
         if (existing.mcpServers) {
           existingServers = existing.mcpServers;
         }
@@ -1335,7 +1193,7 @@ function writeCursorConfig(config) {
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs11.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs10.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(mcpPath);
   }
   return written;
@@ -1343,62 +1201,62 @@ function writeCursorConfig(config) {
 
 // src/writers/backup.ts
 init_constants();
-import fs12 from "fs";
-import path13 from "path";
+import fs11 from "fs";
+import path12 from "path";
 function createBackup(files) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path13.join(BACKUPS_DIR, timestamp);
+  const backupDir = path12.join(BACKUPS_DIR, timestamp);
   for (const file of files) {
-    if (!fs12.existsSync(file)) continue;
-    const dest = path13.join(backupDir, file);
-    const destDir = path13.dirname(dest);
-    if (!fs12.existsSync(destDir)) {
-      fs12.mkdirSync(destDir, { recursive: true });
+    if (!fs11.existsSync(file)) continue;
+    const dest = path12.join(backupDir, file);
+    const destDir = path12.dirname(dest);
+    if (!fs11.existsSync(destDir)) {
+      fs11.mkdirSync(destDir, { recursive: true });
     }
-    fs12.copyFileSync(file, dest);
+    fs11.copyFileSync(file, dest);
   }
   return backupDir;
 }
 function restoreBackup(backupDir, file) {
-  const backupFile = path13.join(backupDir, file);
-  if (!fs12.existsSync(backupFile)) return false;
-  const destDir = path13.dirname(file);
-  if (!fs12.existsSync(destDir)) {
-    fs12.mkdirSync(destDir, { recursive: true });
+  const backupFile = path12.join(backupDir, file);
+  if (!fs11.existsSync(backupFile)) return false;
+  const destDir = path12.dirname(file);
+  if (!fs11.existsSync(destDir)) {
+    fs11.mkdirSync(destDir, { recursive: true });
   }
-  fs12.copyFileSync(backupFile, file);
+  fs11.copyFileSync(backupFile, file);
   return true;
 }
 
 // src/writers/manifest.ts
 init_constants();
-import fs13 from "fs";
-import crypto4 from "crypto";
+import fs12 from "fs";
+import crypto3 from "crypto";
 function readManifest() {
   try {
-    if (!fs13.existsSync(MANIFEST_FILE)) return null;
-    return JSON.parse(fs13.readFileSync(MANIFEST_FILE, "utf-8"));
+    if (!fs12.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs12.readFileSync(MANIFEST_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeManifest(manifest) {
-  if (!fs13.existsSync(CALIBER_DIR)) {
-    fs13.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs12.existsSync(CALIBER_DIR)) {
+    fs12.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs13.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+  fs12.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
 }
 function fileChecksum(filePath) {
-  const content = fs13.readFileSync(filePath);
-  return crypto4.createHash("sha256").update(content).digest("hex");
+  const content = fs12.readFileSync(filePath);
+  return crypto3.createHash("sha256").update(content).digest("hex");
 }
 
 // src/writers/index.ts
 function writeSetup(setup) {
   const filesToWrite = getFilesToWrite(setup);
-  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs14.existsSync(f));
+  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs13.existsSync(f));
   const existingFiles = [
-    ...filesToWrite.filter((f) => fs14.existsSync(f)),
+    ...filesToWrite.filter((f) => fs13.existsSync(f)),
     ...filesToDelete
   ];
   const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
@@ -1411,7 +1269,7 @@ function writeSetup(setup) {
   }
   const deleted = [];
   for (const filePath of filesToDelete) {
-    fs14.unlinkSync(filePath);
+    fs13.unlinkSync(filePath);
     deleted.push(filePath);
   }
   ensureGitignore();
@@ -1441,8 +1299,8 @@ function undoSetup() {
   const removed = [];
   for (const entry of manifest.entries) {
     if (entry.action === "created") {
-      if (fs14.existsSync(entry.path)) {
-        fs14.unlinkSync(entry.path);
+      if (fs13.existsSync(entry.path)) {
+        fs13.unlinkSync(entry.path);
         removed.push(entry.path);
       }
     } else if ((entry.action === "modified" || entry.action === "deleted") && manifest.backupDir) {
@@ -1452,8 +1310,8 @@ function undoSetup() {
     }
   }
   const { MANIFEST_FILE: MANIFEST_FILE2 } = (init_constants(), __toCommonJS(constants_exports));
-  if (fs14.existsSync(MANIFEST_FILE2)) {
-    fs14.unlinkSync(MANIFEST_FILE2);
+  if (fs13.existsSync(MANIFEST_FILE2)) {
+    fs13.unlinkSync(MANIFEST_FILE2);
   }
   return { restored, removed };
 }
@@ -1482,37 +1340,37 @@ function getFilesToWrite(setup) {
 }
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (fs14.existsSync(gitignorePath)) {
-    const content = fs14.readFileSync(gitignorePath, "utf-8");
+  if (fs13.existsSync(gitignorePath)) {
+    const content = fs13.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".caliber/")) {
-      fs14.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+      fs13.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
     }
   } else {
-    fs14.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+    fs13.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
   }
 }
 
 // src/writers/staging.ts
 init_constants();
-import fs15 from "fs";
-import path14 from "path";
-var STAGED_DIR = path14.join(CALIBER_DIR, "staged");
-var PROPOSED_DIR = path14.join(STAGED_DIR, "proposed");
-var CURRENT_DIR = path14.join(STAGED_DIR, "current");
+import fs14 from "fs";
+import path13 from "path";
+var STAGED_DIR = path13.join(CALIBER_DIR, "staged");
+var PROPOSED_DIR = path13.join(STAGED_DIR, "proposed");
+var CURRENT_DIR = path13.join(STAGED_DIR, "current");
 function stageFiles(files, projectDir) {
   cleanupStaging();
   let newFiles = 0;
   let modifiedFiles = 0;
   const stagedFiles = [];
   for (const file of files) {
-    const proposedPath = path14.join(PROPOSED_DIR, file.path);
-    fs15.mkdirSync(path14.dirname(proposedPath), { recursive: true });
-    fs15.writeFileSync(proposedPath, file.content);
-    const originalPath = path14.join(projectDir, file.path);
-    if (fs15.existsSync(originalPath)) {
-      const currentPath = path14.join(CURRENT_DIR, file.path);
-      fs15.mkdirSync(path14.dirname(currentPath), { recursive: true });
-      fs15.copyFileSync(originalPath, currentPath);
+    const proposedPath = path13.join(PROPOSED_DIR, file.path);
+    fs14.mkdirSync(path13.dirname(proposedPath), { recursive: true });
+    fs14.writeFileSync(proposedPath, file.content);
+    const originalPath = path13.join(projectDir, file.path);
+    if (fs14.existsSync(originalPath)) {
+      const currentPath = path13.join(CURRENT_DIR, file.path);
+      fs14.mkdirSync(path13.dirname(currentPath), { recursive: true });
+      fs14.copyFileSync(originalPath, currentPath);
       modifiedFiles++;
       stagedFiles.push({ relativePath: file.path, proposedPath, currentPath, originalPath, isNew: false });
     } else {
@@ -1523,8 +1381,8 @@ function stageFiles(files, projectDir) {
   return { newFiles, modifiedFiles, stagedFiles };
 }
 function cleanupStaging() {
-  if (fs15.existsSync(STAGED_DIR)) {
-    fs15.rmSync(STAGED_DIR, { recursive: true, force: true });
+  if (fs14.existsSync(STAGED_DIR)) {
+    fs14.rmSync(STAGED_DIR, { recursive: true, force: true });
   }
 }
 
@@ -1570,23 +1428,23 @@ function openDiffsInEditor(editor, files) {
 import { createTwoFilesPatch } from "diff";
 
 // src/lib/hooks.ts
-import fs16 from "fs";
-import path15 from "path";
-var SETTINGS_PATH = path15.join(".claude", "settings.json");
+import fs15 from "fs";
+import path14 from "path";
+var SETTINGS_PATH = path14.join(".claude", "settings.json");
 var HOOK_COMMAND = "caliber refresh --quiet";
 var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
 function readSettings() {
-  if (!fs16.existsSync(SETTINGS_PATH)) return {};
+  if (!fs15.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs16.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs15.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  const dir = path15.dirname(SETTINGS_PATH);
-  if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
-  fs16.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  const dir = path14.dirname(SETTINGS_PATH);
+  if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
+  fs15.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
@@ -1636,23 +1494,23 @@ function removeHook() {
 
 // src/lib/state.ts
 init_constants();
-import fs17 from "fs";
-import path16 from "path";
+import fs16 from "fs";
+import path15 from "path";
 import { execSync as execSync3 } from "child_process";
-var STATE_FILE = path16.join(CALIBER_DIR, ".caliber-state.json");
+var STATE_FILE = path15.join(CALIBER_DIR, ".caliber-state.json");
 function readState() {
   try {
-    if (!fs17.existsSync(STATE_FILE)) return null;
-    return JSON.parse(fs17.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs16.existsSync(STATE_FILE)) return null;
+    return JSON.parse(fs16.readFileSync(STATE_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeState(state) {
-  if (!fs17.existsSync(CALIBER_DIR)) {
-    fs17.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs16.existsSync(CALIBER_DIR)) {
+    fs16.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs17.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs16.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
@@ -1757,8 +1615,8 @@ async function initCommand(options) {
   console.log(chalk3.dim("  Configure your coding agent environment\n"));
   console.log(chalk3.bold("  What is Caliber?\n"));
   console.log(chalk3.dim("  Caliber audits your AI agent configurations and suggests targeted"));
-  console.log(chalk3.dim("  improvements. It analyzes CLAUDE.md, .cursorrules, skills, and MCP"));
-  console.log(chalk3.dim("  servers against your actual codebase \u2014 keeping what works, fixing"));
+  console.log(chalk3.dim("  improvements. It analyzes CLAUDE.md, .cursorrules, and skills"));
+  console.log(chalk3.dim("  against your actual codebase \u2014 keeping what works, fixing"));
   console.log(chalk3.dim("  what's stale, and adding what's missing.\n"));
   console.log(chalk3.bold("  How it works:\n"));
   console.log(chalk3.dim("  1. Scan      Analyze your code, dependencies, and file structure"));
@@ -1797,10 +1655,6 @@ async function initCommand(options) {
     cursor_rules_count: fingerprint.existingConfigs.cursorRules?.length ?? 0,
     cursor_skills_count: fingerprint.existingConfigs.cursorSkills?.length ?? 0,
     skills_count: fingerprint.existingConfigs.claudeSkills?.length ?? 0,
-    has_claude_mcp_servers: !!fingerprint.existingConfigs.claudeMcpServers,
-    has_cursor_mcp_servers: !!fingerprint.existingConfigs.cursorMcpServers,
-    claude_mcp_server_count: fingerprint.existingConfigs.claudeMcpServers ? Object.keys(fingerprint.existingConfigs.claudeMcpServers).length : 0,
-    cursor_mcp_server_count: fingerprint.existingConfigs.cursorMcpServers ? Object.keys(fingerprint.existingConfigs.cursorMcpServers).length : 0,
     file_count: fingerprint.fileTree.length
   });
   console.log(chalk3.dim(`  Languages: ${fingerprint.languages.join(", ") || "none detected"}`));
@@ -1808,7 +1662,7 @@ async function initCommand(options) {
   console.log(chalk3.dim(`  Files: ${fingerprint.fileTree.length} found
 `));
   console.log(chalk3.hex("#6366f1").bold("  Step 3/6 \u2014 Match project\n"));
-  console.log(chalk3.dim("  Scanning for existing rules, skills, MCP servers, and teammate setups.\n"));
+  console.log(chalk3.dim("  Scanning for existing rules, skills, and teammate setups.\n"));
   const matchSpinner = ora2("Scanning for existing setup...").start();
   const localConfigs = [];
   const ec = fingerprint.existingConfigs;
@@ -1830,15 +1684,6 @@ async function initCommand(options) {
       localConfigs.push(`.cursor/skills/${skill.slug}/SKILL.md`);
     }
   }
-  const localState = scanLocalState(process.cwd());
-  const claudeMcpServers = localState.filter((i) => i.type === "mcp" && i.platform === "claude").map((i) => i.name);
-  const cursorMcpServers = localState.filter((i) => i.type === "mcp" && i.platform === "cursor").map((i) => i.name);
-  if (claudeMcpServers.length > 0) {
-    localConfigs.push(`.mcp.json (${claudeMcpServers.join(", ")} \u2014 will merge)`);
-  }
-  if (cursorMcpServers.length > 0) {
-    localConfigs.push(`.cursor/mcp.json (${cursorMcpServers.join(", ")} \u2014 will merge)`);
-  }
   let existingSetup = null;
   let existingProjectId = null;
   let hasTeammateSetup = false;
@@ -1893,7 +1738,7 @@ async function initCommand(options) {
   let generatedSetup = null;
   let rawOutput;
   trackEvent("generation_started", { target_agent: targetAgent });
-  const hasExistingConfig = !!(ec.claudeMd || ec.claudeSettings || ec.claudeSkills?.length || ec.cursorrules || ec.cursorRules?.length || ec.claudeMcpServers || ec.cursorMcpServers);
+  const hasExistingConfig = !!(ec.claudeMd || ec.claudeSettings || ec.claudeSkills?.length || ec.cursorrules || ec.cursorRules?.length);
   const genStartTime = Date.now();
   const genSpinner = ora2("Generating setup...").start();
   const genMessages = new SpinnerMessages(genSpinner, GENERATION_MESSAGES, { showElapsedTime: true });
@@ -2152,25 +1997,24 @@ function openReview(method, stagedFiles) {
     console.log(chalk3.dim("  Diffs opened in your editor.\n"));
   } else {
     for (const file of stagedFiles) {
-      console.log(chalk3.bold(`  ${file.relativePath}`));
       if (file.currentPath) {
-        const current = fs18.readFileSync(file.currentPath, "utf-8");
-        const proposed = fs18.readFileSync(file.proposedPath, "utf-8");
-        const patch = createTwoFilesPatch(file.relativePath, file.relativePath, current, proposed, "current", "proposed");
-        for (const line of patch.split("\n").slice(2)) {
-          if (line.startsWith("+")) console.log(chalk3.green(`    ${line}`));
-          else if (line.startsWith("-")) console.log(chalk3.red(`    ${line}`));
-          else console.log(chalk3.dim(`    ${line}`));
+        const currentLines = fs17.readFileSync(file.currentPath, "utf-8").split("\n");
+        const proposedLines = fs17.readFileSync(file.proposedPath, "utf-8").split("\n");
+        const patch = createTwoFilesPatch(file.relativePath, file.relativePath, currentLines.join("\n"), proposedLines.join("\n"));
+        let added = 0, removed = 0;
+        for (const line of patch.split("\n")) {
+          if (line.startsWith("+") && !line.startsWith("+++")) added++;
+          if (line.startsWith("-") && !line.startsWith("---")) removed++;
         }
+        console.log(`    ${chalk3.yellow("~")} ${file.relativePath}  ${chalk3.green(`+${added}`)} ${chalk3.red(`-${removed}`)}`);
       } else {
-        console.log(chalk3.green("    (new file)"));
-        const content = fs18.readFileSync(file.proposedPath, "utf-8");
-        const preview = content.split("\n").slice(0, 20);
-        for (const line of preview) console.log(chalk3.green(`    +${line}`));
-        if (content.split("\n").length > 20) console.log(chalk3.dim(`    ... ${content.split("\n").length - 20} more lines`));
+        const lines = fs17.readFileSync(file.proposedPath, "utf-8").split("\n").length;
+        console.log(`    ${chalk3.green("+")} ${file.relativePath}  ${chalk3.dim(`${lines} lines`)}`);
       }
-      console.log("");
     }
+    console.log("");
+    console.log(chalk3.dim(`  Files staged at .caliber/staged/ for manual inspection.
+`));
   }
 }
 async function promptReviewAction() {
@@ -2195,7 +2039,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs18.existsSync("CLAUDE.md") ? chalk3.yellow("~") : chalk3.green("+");
+      const icon = fs17.existsSync("CLAUDE.md") ? chalk3.yellow("~") : chalk3.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk3.bold("CLAUDE.md")}`);
       if (desc) {
@@ -2207,26 +2051,17 @@ function printSetupSummary(setup) {
     if (Array.isArray(skills) && skills.length > 0) {
       for (const skill of skills) {
         const skillPath = `.claude/skills/${skill.name.replace(/[^a-z0-9-]/gi, "-").toLowerCase()}.md`;
-        const icon = fs18.existsSync(skillPath) ? chalk3.yellow("~") : chalk3.green("+");
+        const icon = fs17.existsSync(skillPath) ? chalk3.yellow("~") : chalk3.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk3.bold(skillPath)}`);
         console.log(chalk3.dim(`    ${desc || summarizeSkill(skill)}`));
         console.log("");
       }
     }
-    const mcpServers = claude.mcpServers;
-    if (mcpServers && Object.keys(mcpServers).length > 0) {
-      const icon = fs18.existsSync(".mcp.json") ? chalk3.yellow("~") : chalk3.green("+");
-      const serverNames = Object.keys(mcpServers);
-      const desc = getDescription(".mcp.json");
-      console.log(`  ${icon} ${chalk3.bold(".mcp.json")}`);
-      console.log(chalk3.dim(`    ${desc || `servers: ${serverNames.join(", ")}`}`));
-      console.log("");
-    }
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs18.existsSync(".cursorrules") ? chalk3.yellow("~") : chalk3.green("+");
+      const icon = fs17.existsSync(".cursorrules") ? chalk3.yellow("~") : chalk3.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk3.bold(".cursorrules")}`);
       if (desc) console.log(chalk3.dim(`    ${desc}`));
@@ -2236,7 +2071,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(cursorSkills) && cursorSkills.length > 0) {
       for (const skill of cursorSkills) {
         const skillPath = `.cursor/skills/${skill.slug}/SKILL.md`;
-        const icon = fs18.existsSync(skillPath) ? chalk3.yellow("~") : chalk3.green("+");
+        const icon = fs17.existsSync(skillPath) ? chalk3.yellow("~") : chalk3.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk3.bold(skillPath)}`);
         if (desc) {
@@ -2252,7 +2087,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rules) && rules.length > 0) {
       for (const rule of rules) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs18.existsSync(rulePath) ? chalk3.yellow("~") : chalk3.green("+");
+        const icon = fs17.existsSync(rulePath) ? chalk3.yellow("~") : chalk3.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk3.bold(rulePath)}`);
         if (desc) {
@@ -2264,15 +2099,6 @@ function printSetupSummary(setup) {
         console.log("");
       }
     }
-    const mcpServers = cursor.mcpServers;
-    if (mcpServers && Object.keys(mcpServers).length > 0) {
-      const icon = fs18.existsSync(".cursor/mcp.json") ? chalk3.yellow("~") : chalk3.green("+");
-      const serverNames = Object.keys(mcpServers);
-      const desc = getDescription(".cursor/mcp.json");
-      console.log(`  ${icon} ${chalk3.bold(".cursor/mcp.json")}`);
-      console.log(chalk3.dim(`    ${desc || `servers: ${serverNames.join(", ")}`}`));
-      console.log("");
-    }
   }
   if (Array.isArray(deletions) && deletions.length > 0) {
     for (const del of deletions) {
@@ -2301,9 +2127,6 @@ function collectSetupFiles(setup) {
         files.push({ path: skillPath, content: skill.content });
       }
     }
-    if (claude.mcpServers && Object.keys(claude.mcpServers).length > 0) {
-      files.push({ path: ".mcp.json", content: JSON.stringify({ mcpServers: claude.mcpServers }, null, 2) });
-    }
   }
   if (cursor) {
     if (cursor.cursorrules) files.push({ path: ".cursorrules", content: cursor.cursorrules });
@@ -2319,9 +2142,6 @@ function collectSetupFiles(setup) {
         files.push({ path: `.cursor/rules/${rule.filename}`, content: rule.content });
       }
     }
-    if (cursor.mcpServers && Object.keys(cursor.mcpServers).length > 0) {
-      files.push({ path: ".cursor/mcp.json", content: JSON.stringify({ mcpServers: cursor.mcpServers }, null, 2) });
-    }
   }
   return files;
 }
@@ -2361,6 +2181,150 @@ function undoCommand() {
 // src/commands/status.ts
 import chalk5 from "chalk";
 import fs19 from "fs";
+
+// src/scanner/index.ts
+import fs18 from "fs";
+import path16 from "path";
+import crypto4 from "crypto";
+function scanLocalState(dir) {
+  const items = [];
+  const claudeMdPath = path16.join(dir, "CLAUDE.md");
+  if (fs18.existsSync(claudeMdPath)) {
+    items.push({
+      type: "rule",
+      platform: "claude",
+      name: "CLAUDE.md",
+      contentHash: hashFile(claudeMdPath),
+      path: claudeMdPath
+    });
+  }
+  const skillsDir = path16.join(dir, ".claude", "skills");
+  if (fs18.existsSync(skillsDir)) {
+    for (const file of fs18.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path16.join(skillsDir, file);
+      items.push({
+        type: "skill",
+        platform: "claude",
+        name: file,
+        contentHash: hashFile(filePath),
+        path: filePath
+      });
+    }
+  }
+  const mcpJsonPath = path16.join(dir, ".mcp.json");
+  if (fs18.existsSync(mcpJsonPath)) {
+    try {
+      const mcpJson = JSON.parse(fs18.readFileSync(mcpJsonPath, "utf-8"));
+      if (mcpJson.mcpServers) {
+        for (const name of Object.keys(mcpJson.mcpServers)) {
+          items.push({
+            type: "mcp",
+            platform: "claude",
+            name,
+            contentHash: hashJson(mcpJson.mcpServers[name]),
+            path: mcpJsonPath
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  const cursorrulesPath = path16.join(dir, ".cursorrules");
+  if (fs18.existsSync(cursorrulesPath)) {
+    items.push({
+      type: "rule",
+      platform: "cursor",
+      name: ".cursorrules",
+      contentHash: hashFile(cursorrulesPath),
+      path: cursorrulesPath
+    });
+  }
+  const cursorRulesDir = path16.join(dir, ".cursor", "rules");
+  if (fs18.existsSync(cursorRulesDir)) {
+    for (const file of fs18.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path16.join(cursorRulesDir, file);
+      items.push({
+        type: "rule",
+        platform: "cursor",
+        name: file,
+        contentHash: hashFile(filePath),
+        path: filePath
+      });
+    }
+  }
+  const cursorSkillsDir = path16.join(dir, ".cursor", "skills");
+  if (fs18.existsSync(cursorSkillsDir)) {
+    try {
+      for (const slug of fs18.readdirSync(cursorSkillsDir)) {
+        const skillFile = path16.join(cursorSkillsDir, slug, "SKILL.md");
+        if (fs18.existsSync(skillFile)) {
+          items.push({
+            type: "skill",
+            platform: "cursor",
+            name: `${slug}/SKILL.md`,
+            contentHash: hashFile(skillFile),
+            path: skillFile
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  const cursorMcpPath = path16.join(dir, ".cursor", "mcp.json");
+  if (fs18.existsSync(cursorMcpPath)) {
+    try {
+      const mcpJson = JSON.parse(fs18.readFileSync(cursorMcpPath, "utf-8"));
+      if (mcpJson.mcpServers) {
+        for (const name of Object.keys(mcpJson.mcpServers)) {
+          items.push({
+            type: "mcp",
+            platform: "cursor",
+            name,
+            contentHash: hashJson(mcpJson.mcpServers[name]),
+            path: cursorMcpPath
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return items;
+}
+function compareState(serverItems, localItems) {
+  const installed = [];
+  const missing = [];
+  const outdated = [];
+  const extra = [];
+  const localMap = /* @__PURE__ */ new Map();
+  for (const item of localItems) {
+    localMap.set(`${item.type}:${item.platform}:${item.name}`, item);
+  }
+  for (const server of serverItems) {
+    const key = `${server.type}:${server.platform}:${server.name}`;
+    const local = localMap.get(key);
+    localMap.delete(key);
+    if (!local) {
+      missing.push(server);
+    } else if (local.contentHash !== server.content_hash) {
+      outdated.push({ server, local });
+    } else {
+      installed.push({ server, local });
+    }
+  }
+  for (const local of localMap.values()) {
+    extra.push(local);
+  }
+  return { installed, missing, outdated, extra };
+}
+function hashFile(filePath) {
+  const text = fs18.readFileSync(filePath, "utf-8");
+  return crypto4.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
+}
+function hashJson(obj) {
+  return crypto4.createHash("sha256").update(JSON.stringify(obj)).digest("hex");
+}
+
+// src/commands/status.ts
 async function statusCommand(options) {
   const auth2 = getStoredAuth();
   const manifest = readManifest();