@caliber-ai/cli 0.18.0 → 0.19.0

package/dist/bin.js

@@ -75,8 +75,8 @@ if (dsn) {
 
 // src/cli.ts
 import { Command } from "commander";
-import fs20 from "fs";
-import path17 from "path";
+import fs22 from "fs";
+import path19 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/commands/init.ts
@@ -84,8 +84,7 @@ import chalk3 from "chalk";
 import ora2 from "ora";
 import readline from "readline";
 import select from "@inquirer/select";
-import fs16 from "fs";
-import { createTwoFilesPatch } from "diff";
+import fs18 from "fs";
 
 // src/auth/token-store.ts
 init_constants();
@@ -328,6 +327,8 @@ ${authUrl}
 
 // src/fingerprint/index.ts
 import crypto2 from "crypto";
+import fs8 from "fs";
+import path9 from "path";
 
 // src/fingerprint/git.ts
 import { execSync } from "child_process";
@@ -605,6 +606,20 @@ function readExistingConfigs(dir) {
     } catch {
     }
   }
+  const cursorSkillsDir = path7.join(dir, ".cursor", "skills");
+  if (fs6.existsSync(cursorSkillsDir)) {
+    try {
+      const slugs = fs6.readdirSync(cursorSkillsDir).filter((f) => {
+        return fs6.statSync(path7.join(cursorSkillsDir, f)).isDirectory();
+      });
+      configs.cursorSkills = slugs.filter((slug) => fs6.existsSync(path7.join(cursorSkillsDir, slug, "SKILL.md"))).map((slug) => ({
+        slug,
+        filename: "SKILL.md",
+        content: fs6.readFileSync(path7.join(cursorSkillsDir, slug, "SKILL.md"), "utf-8")
+      }));
+    } catch {
+    }
+  }
   const mcpJsonPath = path7.join(dir, ".mcp.json");
   if (fs6.existsSync(mcpJsonPath)) {
     try {
@@ -899,6 +914,127 @@ function estimateSummarySize(summary) {
   return summary.path.length + summary.imports.reduce((s, i) => s + i.length, 0) + summary.exports.reduce((s, e) => s + e.length, 0) + summary.functions.reduce((s, f) => s + f.length, 0) + summary.classes.reduce((s, c) => s + c.length, 0) + summary.types.reduce((s, t) => s + t.length, 0) + summary.routes.reduce((s, r) => s + r.length, 0);
 }
 
+// src/api/client.ts
+init_constants();
+async function forceRefreshToken() {
+  const auth2 = getStoredAuth();
+  if (!auth2) return null;
+  try {
+    const resp = await fetch(`${API_URL}/api/auth/refresh`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ refreshToken: auth2.refreshToken })
+    });
+    if (!resp.ok) return null;
+    const { data } = await resp.json();
+    storeAuth({
+      accessToken: data.accessToken,
+      refreshToken: data.refreshToken,
+      expiresIn: data.expiresIn,
+      user: { id: auth2.userId, email: auth2.email }
+    });
+    return data.accessToken;
+  } catch {
+    return null;
+  }
+}
+async function getValidToken() {
+  const auth2 = getStoredAuth();
+  if (!auth2) {
+    throw new Error("Not authenticated. Run `caliber login` first.");
+  }
+  if (!isTokenExpired()) return auth2.accessToken;
+  const refreshed = await forceRefreshToken();
+  if (!refreshed) {
+    throw new Error("Session expired. Run `caliber login` to re-authenticate.");
+  }
+  return refreshed;
+}
+async function apiRequest(path21, options = {}) {
+  let token = await getValidToken();
+  let resp = await fetch(`${API_URL}${path21}`, {
+    method: options.method || "GET",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: options.body ? JSON.stringify(options.body) : void 0
+  });
+  if (resp.status === 401) {
+    const refreshed = await forceRefreshToken();
+    if (!refreshed) {
+      throw new Error("Session expired. Run `caliber login` to re-authenticate.");
+    }
+    token = refreshed;
+    resp = await fetch(`${API_URL}${path21}`, {
+      method: options.method || "GET",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: options.body ? JSON.stringify(options.body) : void 0
+    });
+  }
+  if (!resp.ok) {
+    const error = await resp.json().catch(() => ({ error: resp.statusText }));
+    throw new Error(error.error || `API error: ${resp.status}`);
+  }
+  const json = await resp.json();
+  return json.data;
+}
+async function apiStream(path21, body, onChunk, onComplete, onError, onStatus) {
+  let token = await getValidToken();
+  let resp = await fetch(`${API_URL}${path21}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (resp.status === 401) {
+    const refreshed = await forceRefreshToken();
+    if (!refreshed) {
+      throw new Error("Session expired. Run `caliber login` to re-authenticate.");
+    }
+    token = refreshed;
+    resp = await fetch(`${API_URL}${path21}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify(body)
+    });
+  }
+  if (!resp.ok || !resp.body) {
+    throw new Error(`API error: ${resp.status}`);
+  }
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      const data = line.slice(6);
+      if (data === "[DONE]") return;
+      try {
+        const parsed = JSON.parse(data);
+        if (parsed.type === "chunk") onChunk(parsed.content);
+        else if (parsed.type === "status" && onStatus) onStatus(parsed.message);
+        else if (parsed.type === "complete") onComplete({ setup: parsed.setup, explanation: parsed.explanation, raw: parsed.raw });
+        else if (parsed.type === "error") onError(parsed.message);
+      } catch {
+      }
+    }
+  }
+}
+
 // src/fingerprint/index.ts
 function collectFingerprint(dir) {
   const gitRemoteUrl = getGitRemoteUrl();
@@ -925,15 +1061,68 @@ function computeFingerprintHash(fingerprint) {
   ].join("::");
   return crypto2.createHash("sha256").update(key).digest("hex");
 }
+var DEP_FILE_PATTERNS = [
+  "package.json",
+  "pyproject.toml",
+  "requirements.txt",
+  "setup.py",
+  "Pipfile",
+  "Cargo.toml",
+  "go.mod",
+  "Gemfile",
+  "build.gradle",
+  "pom.xml",
+  "composer.json"
+];
+var MAX_CONTENT_SIZE = 50 * 1024;
+async function enrichFingerprintWithLLM(fingerprint, dir) {
+  try {
+    const fileContents = {};
+    let totalSize = 0;
+    for (const treePath of fingerprint.fileTree) {
+      const basename = path9.basename(treePath);
+      if (!DEP_FILE_PATTERNS.includes(basename)) continue;
+      const fullPath = path9.join(dir, treePath);
+      if (!fs8.existsSync(fullPath)) continue;
+      try {
+        const content = fs8.readFileSync(fullPath, "utf-8");
+        if (totalSize + content.length > MAX_CONTENT_SIZE) break;
+        fileContents[treePath] = content;
+        totalSize += content.length;
+      } catch {
+        continue;
+      }
+    }
+    if (Object.keys(fileContents).length === 0 && fingerprint.fileTree.length === 0) return;
+    const result = await apiRequest(
+      "/api/fingerprint/detect",
+      {
+        method: "POST",
+        body: { fileTree: fingerprint.fileTree, fileContents }
+      }
+    );
+    if (result.languages?.length) {
+      const langSet = new Set(fingerprint.languages);
+      for (const lang of result.languages) langSet.add(lang);
+      fingerprint.languages = [...langSet];
+    }
+    if (result.frameworks?.length) {
+      const fwSet = new Set(fingerprint.frameworks);
+      for (const fw of result.frameworks) fwSet.add(fw);
+      fingerprint.frameworks = [...fwSet];
+    }
+  } catch {
+  }
+}
 
 // src/scanner/index.ts
-import fs8 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path10 from "path";
 import crypto3 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path9.join(dir, "CLAUDE.md");
-  if (fs8.existsSync(claudeMdPath)) {
+  const claudeMdPath = path10.join(dir, "CLAUDE.md");
+  if (fs9.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -942,10 +1131,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path9.join(dir, ".claude", "skills");
-  if (fs8.existsSync(skillsDir)) {
-    for (const file of fs8.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path9.join(skillsDir, file);
+  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",
@@ -955,10 +1144,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path9.join(dir, ".mcp.json");
-  if (fs8.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path10.join(dir, ".mcp.json");
+  if (fs9.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs8.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs9.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -973,8 +1162,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path9.join(dir, ".cursorrules");
-  if (fs8.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path10.join(dir, ".cursorrules");
+  if (fs9.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -983,10 +1172,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path9.join(dir, ".cursor", "rules");
-  if (fs8.existsSync(cursorRulesDir)) {
-    for (const file of fs8.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path9.join(cursorRulesDir, file);
+  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",
@@ -996,10 +1185,28 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorMcpPath = path9.join(dir, ".cursor", "mcp.json");
-  if (fs8.existsSync(cursorMcpPath)) {
+  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(fs8.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs9.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -1043,196 +1250,84 @@ function compareState(serverItems, localItems) {
   return { installed, missing, outdated, extra };
 }
 function hashFile(filePath) {
-  const text = fs8.readFileSync(filePath, "utf-8");
+  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/api/client.ts
-init_constants();
-async function forceRefreshToken() {
-  const auth2 = getStoredAuth();
-  if (!auth2) return null;
-  try {
-    const resp = await fetch(`${API_URL}/api/auth/refresh`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ refreshToken: auth2.refreshToken })
-    });
-    if (!resp.ok) return null;
-    const { data } = await resp.json();
-    storeAuth({
-      accessToken: data.accessToken,
-      refreshToken: data.refreshToken,
-      expiresIn: data.expiresIn,
-      user: { id: auth2.userId, email: auth2.email }
-    });
-    return data.accessToken;
-  } catch {
-    return null;
-  }
-}
-async function getValidToken() {
-  const auth2 = getStoredAuth();
-  if (!auth2) {
-    throw new Error("Not authenticated. Run `caliber login` first.");
-  }
-  if (!isTokenExpired()) return auth2.accessToken;
-  const refreshed = await forceRefreshToken();
-  if (!refreshed) {
-    throw new Error("Session expired. Run `caliber login` to re-authenticate.");
-  }
-  return refreshed;
-}
-async function apiRequest(path19, options = {}) {
-  let token = await getValidToken();
-  let resp = await fetch(`${API_URL}${path19}`, {
-    method: options.method || "GET",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: options.body ? JSON.stringify(options.body) : void 0
-  });
-  if (resp.status === 401) {
-    const refreshed = await forceRefreshToken();
-    if (!refreshed) {
-      throw new Error("Session expired. Run `caliber login` to re-authenticate.");
-    }
-    token = refreshed;
-    resp = await fetch(`${API_URL}${path19}`, {
-      method: options.method || "GET",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`
-      },
-      body: options.body ? JSON.stringify(options.body) : void 0
-    });
-  }
-  if (!resp.ok) {
-    const error = await resp.json().catch(() => ({ error: resp.statusText }));
-    throw new Error(error.error || `API error: ${resp.status}`);
-  }
-  const json = await resp.json();
-  return json.data;
-}
-async function apiStream(path19, body, onChunk, onComplete, onError, onStatus) {
-  let token = await getValidToken();
-  let resp = await fetch(`${API_URL}${path19}`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify(body)
-  });
-  if (resp.status === 401) {
-    const refreshed = await forceRefreshToken();
-    if (!refreshed) {
-      throw new Error("Session expired. Run `caliber login` to re-authenticate.");
-    }
-    token = refreshed;
-    resp = await fetch(`${API_URL}${path19}`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify(body)
-    });
-  }
-  if (!resp.ok || !resp.body) {
-    throw new Error(`API error: ${resp.status}`);
-  }
-  const reader = resp.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop() || "";
-    for (const line of lines) {
-      if (!line.startsWith("data: ")) continue;
-      const data = line.slice(6);
-      if (data === "[DONE]") return;
-      try {
-        const parsed = JSON.parse(data);
-        if (parsed.type === "chunk") onChunk(parsed.content);
-        else if (parsed.type === "status" && onStatus) onStatus(parsed.message);
-        else if (parsed.type === "complete") onComplete({ setup: parsed.setup, explanation: parsed.explanation, raw: parsed.raw });
-        else if (parsed.type === "error") onError(parsed.message);
-      } catch {
-      }
-    }
-  }
-}
-
 // src/writers/index.ts
-import fs13 from "fs";
+import fs14 from "fs";
 
 // src/writers/claude/index.ts
-import fs9 from "fs";
-import path10 from "path";
+import fs10 from "fs";
+import path11 from "path";
 function writeClaudeConfig(config) {
   const written = [];
-  fs9.writeFileSync("CLAUDE.md", config.claudeMd);
+  fs10.writeFileSync("CLAUDE.md", config.claudeMd);
   written.push("CLAUDE.md");
   if (config.skills?.length) {
-    const skillsDir = path10.join(".claude", "skills");
-    if (!fs9.existsSync(skillsDir)) fs9.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path11.join(".claude", "skills");
+    if (!fs10.existsSync(skillsDir)) fs10.mkdirSync(skillsDir, { recursive: true });
     for (const skill of config.skills) {
       const filename = `${skill.name.replace(/[^a-z0-9-]/gi, "-").toLowerCase()}.md`;
-      const skillPath = path10.join(skillsDir, filename);
-      fs9.writeFileSync(skillPath, skill.content);
+      const skillPath = path11.join(skillsDir, filename);
+      fs10.writeFileSync(skillPath, skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     let existingServers = {};
     try {
-      if (fs9.existsSync(".mcp.json")) {
-        const existing = JSON.parse(fs9.readFileSync(".mcp.json", "utf-8"));
+      if (fs10.existsSync(".mcp.json")) {
+        const existing = JSON.parse(fs10.readFileSync(".mcp.json", "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs9.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs10.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(".mcp.json");
   }
   return written;
 }
 
 // src/writers/cursor/index.ts
-import fs10 from "fs";
-import path11 from "path";
+import fs11 from "fs";
+import path12 from "path";
 function writeCursorConfig(config) {
   const written = [];
   if (config.cursorrules) {
-    fs10.writeFileSync(".cursorrules", config.cursorrules);
+    fs11.writeFileSync(".cursorrules", config.cursorrules);
     written.push(".cursorrules");
   }
   if (config.rules?.length) {
-    const rulesDir = path11.join(".cursor", "rules");
-    if (!fs10.existsSync(rulesDir)) fs10.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path12.join(".cursor", "rules");
+    if (!fs11.existsSync(rulesDir)) fs11.mkdirSync(rulesDir, { recursive: true });
     for (const rule of config.rules) {
-      const rulePath = path11.join(rulesDir, rule.filename);
-      fs10.writeFileSync(rulePath, rule.content);
+      const rulePath = path12.join(rulesDir, rule.filename);
+      fs11.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);
+      written.push(skillPath);
+    }
+  }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     const cursorDir = ".cursor";
-    if (!fs10.existsSync(cursorDir)) fs10.mkdirSync(cursorDir, { recursive: true });
-    const mcpPath = path11.join(cursorDir, "mcp.json");
+    if (!fs11.existsSync(cursorDir)) fs11.mkdirSync(cursorDir, { recursive: true });
+    const mcpPath = path12.join(cursorDir, "mcp.json");
     let existingServers = {};
     try {
-      if (fs10.existsSync(mcpPath)) {
-        const existing = JSON.parse(fs10.readFileSync(mcpPath, "utf-8"));
+      if (fs11.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs11.readFileSync(mcpPath, "utf-8"));
         if (existing.mcpServers) {
           existingServers = existing.mcpServers;
         }
@@ -1240,7 +1335,7 @@ function writeCursorConfig(config) {
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs10.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs11.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(mcpPath);
   }
   return written;
@@ -1248,62 +1343,62 @@ function writeCursorConfig(config) {
 
 // src/writers/backup.ts
 init_constants();
-import fs11 from "fs";
-import path12 from "path";
+import fs12 from "fs";
+import path13 from "path";
 function createBackup(files) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path12.join(BACKUPS_DIR, timestamp);
+  const backupDir = path13.join(BACKUPS_DIR, timestamp);
   for (const file of files) {
-    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 });
+    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 });
     }
-    fs11.copyFileSync(file, dest);
+    fs12.copyFileSync(file, dest);
   }
   return backupDir;
 }
 function restoreBackup(backupDir, file) {
-  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 });
+  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 });
   }
-  fs11.copyFileSync(backupFile, file);
+  fs12.copyFileSync(backupFile, file);
   return true;
 }
 
 // src/writers/manifest.ts
 init_constants();
-import fs12 from "fs";
+import fs13 from "fs";
 import crypto4 from "crypto";
 function readManifest() {
   try {
-    if (!fs12.existsSync(MANIFEST_FILE)) return null;
-    return JSON.parse(fs12.readFileSync(MANIFEST_FILE, "utf-8"));
+    if (!fs13.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs13.readFileSync(MANIFEST_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeManifest(manifest) {
-  if (!fs12.existsSync(CALIBER_DIR)) {
-    fs12.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs13.existsSync(CALIBER_DIR)) {
+    fs13.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs12.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+  fs13.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
 }
 function fileChecksum(filePath) {
-  const content = fs12.readFileSync(filePath);
+  const content = fs13.readFileSync(filePath);
   return crypto4.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) => fs13.existsSync(f));
+  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs14.existsSync(f));
   const existingFiles = [
-    ...filesToWrite.filter((f) => fs13.existsSync(f)),
+    ...filesToWrite.filter((f) => fs14.existsSync(f)),
     ...filesToDelete
   ];
   const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
@@ -1316,7 +1411,7 @@ function writeSetup(setup) {
   }
   const deleted = [];
   for (const filePath of filesToDelete) {
-    fs13.unlinkSync(filePath);
+    fs14.unlinkSync(filePath);
     deleted.push(filePath);
   }
   ensureGitignore();
@@ -1346,8 +1441,8 @@ function undoSetup() {
   const removed = [];
   for (const entry of manifest.entries) {
     if (entry.action === "created") {
-      if (fs13.existsSync(entry.path)) {
-        fs13.unlinkSync(entry.path);
+      if (fs14.existsSync(entry.path)) {
+        fs14.unlinkSync(entry.path);
         removed.push(entry.path);
       }
     } else if ((entry.action === "modified" || entry.action === "deleted") && manifest.backupDir) {
@@ -1357,8 +1452,8 @@ function undoSetup() {
     }
   }
   const { MANIFEST_FILE: MANIFEST_FILE2 } = (init_constants(), __toCommonJS(constants_exports));
-  if (fs13.existsSync(MANIFEST_FILE2)) {
-    fs13.unlinkSync(MANIFEST_FILE2);
+  if (fs14.existsSync(MANIFEST_FILE2)) {
+    fs14.unlinkSync(MANIFEST_FILE2);
   }
   return { restored, removed };
 }
@@ -1378,40 +1473,123 @@ function getFilesToWrite(setup) {
     if (setup.cursor.rules) {
       for (const r of setup.cursor.rules) files.push(`.cursor/rules/${r.filename}`);
     }
+    if (setup.cursor.skills) {
+      for (const s of setup.cursor.skills) files.push(`.cursor/skills/${s.slug}/SKILL.md`);
+    }
     if (setup.cursor.mcpServers) files.push(".cursor/mcp.json");
   }
   return files;
 }
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (fs13.existsSync(gitignorePath)) {
-    const content = fs13.readFileSync(gitignorePath, "utf-8");
+  if (fs14.existsSync(gitignorePath)) {
+    const content = fs14.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".caliber/")) {
-      fs13.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+      fs14.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
     }
   } else {
-    fs13.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+    fs14.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");
+function stageFiles(files, projectDir) {
+  cleanupStaging();
+  let newFiles = 0;
+  let modifiedFiles = 0;
+  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);
+      modifiedFiles++;
+    } else {
+      newFiles++;
+    }
+  }
+  return { newFiles, modifiedFiles };
+}
+function getStagedProposedDir() {
+  return PROPOSED_DIR;
+}
+function cleanupStaging() {
+  if (fs15.existsSync(STAGED_DIR)) {
+    fs15.rmSync(STAGED_DIR, { recursive: true, force: true });
+  }
+}
+
+// src/utils/editor.ts
+import { execSync as execSync2 } from "child_process";
+function commandExists(cmd) {
+  try {
+    execSync2(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function openInEditor(dirPath) {
+  const editors = ["cursor", "code"];
+  for (const editor of editors) {
+    if (commandExists(editor)) {
+      try {
+        execSync2(`${editor} --diff "${dirPath}" "${dirPath}"`, { stdio: "ignore" });
+        return true;
+      } catch {
+        try {
+          execSync2(`${editor} "${dirPath}"`, { stdio: "ignore" });
+          return true;
+        } catch {
+          continue;
+        }
+      }
+    }
+  }
+  const envEditor = process.env.EDITOR;
+  if (envEditor && commandExists(envEditor)) {
+    try {
+      execSync2(`${envEditor} "${dirPath}"`, { stdio: "ignore" });
+      return true;
+    } catch {
+    }
+  }
+  try {
+    const openCmd = process.platform === "darwin" ? "open" : "xdg-open";
+    execSync2(`${openCmd} "${dirPath}"`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
   }
 }
 
 // src/lib/hooks.ts
-import fs14 from "fs";
-import path13 from "path";
-var SETTINGS_PATH = path13.join(".claude", "settings.json");
+import fs16 from "fs";
+import path15 from "path";
+var SETTINGS_PATH = path15.join(".claude", "settings.json");
 var HOOK_COMMAND = "caliber refresh --quiet";
 var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
 function readSettings() {
-  if (!fs14.existsSync(SETTINGS_PATH)) return {};
+  if (!fs16.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs14.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs16.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  const dir = path13.dirname(SETTINGS_PATH);
-  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
-  fs14.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  const dir = path15.dirname(SETTINGS_PATH);
+  if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
+  fs16.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
@@ -1461,27 +1639,27 @@ function removeHook() {
 
 // src/lib/state.ts
 init_constants();
-import fs15 from "fs";
-import path14 from "path";
-import { execSync as execSync2 } from "child_process";
-var STATE_FILE = path14.join(CALIBER_DIR, ".caliber-state.json");
+import fs17 from "fs";
+import path16 from "path";
+import { execSync as execSync3 } from "child_process";
+var STATE_FILE = path16.join(CALIBER_DIR, ".caliber-state.json");
 function readState() {
   try {
-    if (!fs15.existsSync(STATE_FILE)) return null;
-    return JSON.parse(fs15.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs17.existsSync(STATE_FILE)) return null;
+    return JSON.parse(fs17.readFileSync(STATE_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeState(state) {
-  if (!fs15.existsSync(CALIBER_DIR)) {
-    fs15.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs17.existsSync(CALIBER_DIR)) {
+    fs17.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs15.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs17.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
-    return execSync2("git rev-parse HEAD", {
+    return execSync3("git rev-parse HEAD", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -1611,6 +1789,7 @@ async function initCommand(options) {
   const fingerprint = collectFingerprint(process.cwd());
   const hash = computeFingerprintHash(fingerprint);
   spinner.succeed("Project analyzed");
+  const enrichmentPromise = enrichFingerprintWithLLM(fingerprint, process.cwd());
   trackEvent("scan_completed", {
     languages: fingerprint.languages,
     frameworks: fingerprint.frameworks,
@@ -1619,6 +1798,7 @@ async function initCommand(options) {
     has_claude_settings: !!fingerprint.existingConfigs.claudeSettings,
     has_cursorrules: !!fingerprint.existingConfigs.cursorrules,
     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,
@@ -1648,6 +1828,11 @@ async function initCommand(options) {
       localConfigs.push(`.cursor/rules/${rule.filename}`);
     }
   }
+  if (Array.isArray(ec.cursorSkills)) {
+    for (const skill of ec.cursorSkills) {
+      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);
@@ -1703,6 +1888,7 @@ async function initCommand(options) {
   if (isEmpty) {
     fingerprint.description = await promptInput("What will you build in this project?");
   }
+  await enrichmentPromise;
   console.log(chalk3.hex("#6366f1").bold("  Step 4/6 \u2014 Auditing your configs\n"));
   console.log(chalk3.dim("  AI is auditing your CLAUDE.md, skills, and rules against your"));
   console.log(chalk3.dim("  project's actual codebase and conventions.\n"));
@@ -1762,25 +1948,41 @@ async function initCommand(options) {
   genSpinner.succeed(`Setup generated ${chalk3.dim(`in ${timeStr}`)}`);
   printSetupSummary(generatedSetup);
   console.log(chalk3.hex("#6366f1").bold("  Step 5/6 \u2014 Review\n"));
-  console.log(chalk3.dim("  Review the proposed files. You can accept, refine via chat,"));
-  console.log(chalk3.dim("  or preview any file to see exactly what will be written.\n"));
-  let action = await promptAction();
-  while (action === "preview") {
-    await promptFilePreview(generatedSetup);
-    action = await promptAction();
-  }
-  if (action === "decline") {
-    trackEvent("setup_declined");
-    console.log(chalk3.dim("Setup declined. No files were modified."));
-    return;
+  const setupFiles = collectSetupFiles(generatedSetup);
+  const { newFiles, modifiedFiles } = stageFiles(setupFiles, process.cwd());
+  const stagedDir = getStagedProposedDir();
+  const editorOpened = openInEditor(stagedDir);
+  if (editorOpened) {
+    console.log(chalk3.dim("  Proposed files opened in your editor for review."));
+  } else {
+    console.log(chalk3.dim("  Staged files written to .caliber/staged/proposed/ for review."));
   }
-  if (action === "refine") {
+  console.log(chalk3.dim(`  ${chalk3.green(`${newFiles} new`)} / ${chalk3.yellow(`${modifiedFiles} modified`)} file${newFiles + modifiedFiles !== 1 ? "s" : ""}
+`));
+  let action = await promptReviewAction();
+  while (action === "refine") {
     generatedSetup = await refineLoop(generatedSetup, targetAgent);
     if (!generatedSetup) {
+      cleanupStaging();
       trackEvent("refinement_cancelled");
       console.log(chalk3.dim("Refinement cancelled. No files were modified."));
       return;
     }
+    const updatedFiles = collectSetupFiles(generatedSetup);
+    const restaged = stageFiles(updatedFiles, process.cwd());
+    if (editorOpened) {
+      console.log(chalk3.dim("  Updated files re-staged. Check your editor for changes."));
+    }
+    console.log(chalk3.dim(`  ${chalk3.green(`${restaged.newFiles} new`)} / ${chalk3.yellow(`${restaged.modifiedFiles} modified`)} file${restaged.newFiles + restaged.modifiedFiles !== 1 ? "s" : ""}
+`));
+    printSetupSummary(generatedSetup);
+    action = await promptReviewAction();
+  }
+  cleanupStaging();
+  if (action === "decline") {
+    trackEvent("setup_declined");
+    console.log(chalk3.dim("Setup declined. No files were modified."));
+    return;
   }
   console.log(chalk3.hex("#6366f1").bold("  Step 6/6 \u2014 Apply & sync\n"));
   console.log(chalk3.dim("  Writing config files to your project and syncing to Caliber so"));
@@ -1931,13 +2133,12 @@ async function promptAgent() {
     ]
   });
 }
-async function promptAction() {
+async function promptReviewAction() {
   return select({
     message: "What would you like to do?",
     choices: [
       { name: "Accept and apply", value: "accept" },
       { name: "Refine via chat", value: "refine" },
-      { name: "Preview a file", value: "preview" },
       { name: "Decline", value: "decline" }
     ]
   });
@@ -1954,7 +2155,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs16.existsSync("CLAUDE.md") ? chalk3.yellow("~") : chalk3.green("+");
+      const icon = fs18.existsSync("CLAUDE.md") ? chalk3.yellow("~") : chalk3.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk3.bold("CLAUDE.md")}`);
       if (desc) {
@@ -1966,7 +2167,7 @@ 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 = fs16.existsSync(skillPath) ? chalk3.yellow("~") : chalk3.green("+");
+        const icon = fs18.existsSync(skillPath) ? chalk3.yellow("~") : chalk3.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk3.bold(skillPath)}`);
         console.log(chalk3.dim(`    ${desc || summarizeSkill(skill)}`));
@@ -1975,7 +2176,7 @@ function printSetupSummary(setup) {
     }
     const mcpServers = claude.mcpServers;
     if (mcpServers && Object.keys(mcpServers).length > 0) {
-      const icon = fs16.existsSync(".mcp.json") ? chalk3.yellow("~") : chalk3.green("+");
+      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")}`);
@@ -1985,17 +2186,33 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs16.existsSync(".cursorrules") ? chalk3.yellow("~") : chalk3.green("+");
+      const icon = fs18.existsSync(".cursorrules") ? chalk3.yellow("~") : chalk3.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk3.bold(".cursorrules")}`);
       if (desc) console.log(chalk3.dim(`    ${desc}`));
       console.log("");
     }
+    const cursorSkills = cursor.skills;
+    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 desc = getDescription(skillPath);
+        console.log(`  ${icon} ${chalk3.bold(skillPath)}`);
+        if (desc) {
+          console.log(chalk3.dim(`    ${desc}`));
+        } else {
+          const firstLine = skill.content.split("\n").filter((l) => l.trim() && !l.trim().startsWith("#") && !l.trim().startsWith("---"))[0];
+          if (firstLine) console.log(chalk3.dim(`    ${firstLine.trim().slice(0, 80)}`));
+        }
+        console.log("");
+      }
+    }
     const rules = cursor.rules;
     if (Array.isArray(rules) && rules.length > 0) {
       for (const rule of rules) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs16.existsSync(rulePath) ? chalk3.yellow("~") : chalk3.green("+");
+        const icon = fs18.existsSync(rulePath) ? chalk3.yellow("~") : chalk3.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk3.bold(rulePath)}`);
         if (desc) {
@@ -2009,7 +2226,7 @@ function printSetupSummary(setup) {
     }
     const mcpServers = cursor.mcpServers;
     if (mcpServers && Object.keys(mcpServers).length > 0) {
-      const icon = fs16.existsSync(".cursor/mcp.json") ? chalk3.yellow("~") : chalk3.green("+");
+      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")}`);
@@ -2050,6 +2267,12 @@ function collectSetupFiles(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) files.push({ path: ".cursorrules", content: cursor.cursorrules });
+    const cursorSkills = cursor.skills;
+    if (Array.isArray(cursorSkills)) {
+      for (const skill of cursorSkills) {
+        files.push({ path: `.cursor/skills/${skill.slug}/SKILL.md`, content: skill.content });
+      }
+    }
     const rules = cursor.rules;
     if (Array.isArray(rules)) {
       for (const rule of rules) {
@@ -2062,60 +2285,6 @@ function collectSetupFiles(setup) {
   }
   return files;
 }
-function previewNewFile(filePath, content, maxLines = 40) {
-  const lines = content.split("\n");
-  const displayLines = lines.slice(0, maxLines);
-  console.log("");
-  console.log(`  ${chalk3.green("+ new")} ${chalk3.bold(filePath)}`);
-  console.log(chalk3.dim("  \u2500".repeat(30)));
-  for (const line of displayLines) {
-    console.log(`  ${chalk3.green("+")} ${line}`);
-  }
-  if (lines.length > maxLines) {
-    console.log("");
-    console.log(chalk3.dim(`  ... ${lines.length - maxLines} more lines (${lines.length} total)`));
-  }
-  console.log("");
-}
-function previewDiff(filePath, oldContent, newContent) {
-  const patch = createTwoFilesPatch(filePath, filePath, oldContent, newContent, "current", "proposed", { context: 3 });
-  const patchLines = patch.split("\n").slice(2);
-  console.log("");
-  console.log(`  ${chalk3.yellow("~ modified")} ${chalk3.bold(filePath)}`);
-  console.log(chalk3.dim("  \u2500".repeat(30)));
-  for (const line of patchLines) {
-    if (line.startsWith("@@")) {
-      console.log(`  ${chalk3.cyan(line)}`);
-    } else if (line.startsWith("+")) {
-      console.log(`  ${chalk3.green(line)}`);
-    } else if (line.startsWith("-")) {
-      console.log(`  ${chalk3.red(line)}`);
-    } else {
-      console.log(`  ${chalk3.dim(line)}`);
-    }
-  }
-  console.log("");
-}
-async function promptFilePreview(setup) {
-  const files = collectSetupFiles(setup);
-  if (files.length === 0) {
-    console.log(chalk3.dim("\n  No files to preview.\n"));
-    return;
-  }
-  const choices = files.map((f, i) => {
-    const exists = fs16.existsSync(f.path);
-    const icon = exists ? chalk3.yellow("~") : chalk3.green("+");
-    return { name: `${icon} ${f.path}`, value: i };
-  });
-  const choice = await select({ message: "Which file to preview?", choices });
-  const file = files[choice];
-  if (fs16.existsSync(file.path)) {
-    const existing = fs16.readFileSync(file.path, "utf-8");
-    previewDiff(file.path, existing, file.content);
-  } else {
-    previewNewFile(file.path, file.content);
-  }
-}
 
 // src/commands/undo.ts
 import chalk4 from "chalk";
@@ -2151,7 +2320,7 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk5 from "chalk";
-import fs17 from "fs";
+import fs19 from "fs";
 async function statusCommand(options) {
   const auth2 = getStoredAuth();
   const manifest = readManifest();
@@ -2176,7 +2345,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk5.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs17.existsSync(entry.path);
+    const exists = fs19.existsSync(entry.path);
     const icon = exists ? chalk5.green("\u2713") : chalk5.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -2324,7 +2493,7 @@ function detectLocalPlatforms() {
 }
 function getSkillPath(platform, slug) {
   if (platform === "cursor") {
-    return join(".cursor", "rules", `${slug}.mdc`);
+    return join(".cursor", "skills", slug, "SKILL.md");
   }
   return join(".claude", "skills", `${slug}.md`);
 }
@@ -2811,13 +2980,13 @@ async function diffCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs19 from "fs";
-import path16 from "path";
+import fs21 from "fs";
+import path18 from "path";
 import chalk11 from "chalk";
 import ora8 from "ora";
 
 // src/lib/git-diff.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 var MAX_DIFF_BYTES = 1e5;
 var DOC_PATTERNS = [
   "CLAUDE.md",
@@ -2831,7 +3000,7 @@ function excludeArgs() {
 }
 function safeExec(cmd) {
   try {
-    return execSync3(cmd, {
+    return execSync4(cmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       maxBuffer: 10 * 1024 * 1024
@@ -2889,37 +3058,37 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs18 from "fs";
-import path15 from "path";
+import fs20 from "fs";
+import path17 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs18.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs20.writeFileSync("CLAUDE.md", docs.claudeMd);
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs18.writeFileSync("README.md", docs.readmeMd);
+    fs20.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs18.writeFileSync(".cursorrules", docs.cursorrules);
+    fs20.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path15.join(".cursor", "rules");
-    if (!fs18.existsSync(rulesDir)) fs18.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path17.join(".cursor", "rules");
+    if (!fs20.existsSync(rulesDir)) fs20.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      const filePath = path15.join(rulesDir, rule.filename);
-      fs18.writeFileSync(filePath, rule.content);
+      const filePath = path17.join(rulesDir, rule.filename);
+      fs20.writeFileSync(filePath, rule.content);
       written.push(filePath);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path15.join(".claude", "skills");
-    if (!fs18.existsSync(skillsDir)) fs18.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path17.join(".claude", "skills");
+    if (!fs20.existsSync(skillsDir)) fs20.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      const filePath = path15.join(skillsDir, skill.filename);
-      fs18.writeFileSync(filePath, skill.content);
+      const filePath = path17.join(skillsDir, skill.filename);
+      fs20.writeFileSync(filePath, skill.content);
       written.push(filePath);
     }
   }
@@ -2933,11 +3102,11 @@ function log(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs19.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs21.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path16.join(parentDir, entry.name);
-      if (fs19.existsSync(path16.join(childPath, ".git"))) {
+      const childPath = path18.join(parentDir, entry.name);
+      if (fs21.existsSync(path18.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -3040,7 +3209,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path16.basename(repo);
+      const repoName = path18.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -3182,9 +3351,9 @@ async function reviewCommand(message, options) {
 }
 
 // src/cli.ts
-var __dirname2 = path17.dirname(fileURLToPath3(import.meta.url));
+var __dirname2 = path19.dirname(fileURLToPath3(import.meta.url));
 var pkg3 = JSON.parse(
-  fs20.readFileSync(path17.resolve(__dirname2, "..", "package.json"), "utf-8")
+  fs22.readFileSync(path19.resolve(__dirname2, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg3.version}-local` : pkg3.version;
@@ -3206,22 +3375,22 @@ hooks.command("remove").description("Remove auto-refresh SessionEnd hook").actio
 hooks.command("status").description("Check if auto-refresh hook is installed").action(hooksStatusCommand);
 
 // src/utils/version-check.ts
-import fs21 from "fs";
-import path18 from "path";
+import fs23 from "fs";
+import path20 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 import chalk14 from "chalk";
 import ora10 from "ora";
 import confirm3 from "@inquirer/confirm";
-var __dirname_vc = path18.dirname(fileURLToPath4(import.meta.url));
+var __dirname_vc = path20.dirname(fileURLToPath4(import.meta.url));
 var pkg4 = JSON.parse(
-  fs21.readFileSync(path18.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs23.readFileSync(path20.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getInstalledVersion() {
   try {
-    const globalRoot = execSync4("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const pkgPath = path18.join(globalRoot, "@caliber-ai", "cli", "package.json");
-    return JSON.parse(fs21.readFileSync(pkgPath, "utf-8")).version;
+    const globalRoot = execSync5("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const pkgPath = path20.join(globalRoot, "@caliber-ai", "cli", "package.json");
+    return JSON.parse(fs23.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -3264,7 +3433,7 @@ Update available: ${current} -> ${latest}`)
     }
     const spinner = ora10("Updating @caliber-ai/cli...").start();
     try {
-      execSync4(`npm install -g @caliber-ai/cli@${latest} --prefer-online`, { stdio: "pipe", timeout: 6e4 });
+      execSync5(`npm install -g @caliber-ai/cli@${latest} --prefer-online`, { stdio: "pipe", timeout: 6e4 });
       const installed = getInstalledVersion();
       if (installed !== latest) {
         spinner.fail(`Update incomplete \u2014 got ${installed ?? "unknown"}, expected ${latest}`);
@@ -3277,7 +3446,7 @@ Update available: ${current} -> ${latest}`)
       console.log(chalk14.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
-      execSync4(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
+      execSync5(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
         stdio: "inherit",
         env: { ...process.env, CALIBER_SKIP_UPDATE_CHECK: "1" }
       });