@caliber-ai/cli 0.4.2 → 0.5.0

package/dist/bin.js

@@ -75,15 +75,15 @@ if (dsn) {
 
 // src/cli.ts
 import { Command } from "commander";
-import fs16 from "fs";
-import path13 from "path";
+import fs19 from "fs";
+import path16 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/commands/init.ts
 import chalk2 from "chalk";
 import ora2 from "ora";
 import readline from "readline";
-import fs13 from "fs";
+import fs15 from "fs";
 
 // src/auth/token-store.ts
 init_constants();
@@ -343,6 +343,9 @@ function getGitRemoteUrl() {
     return void 0;
   }
 }
+function isGitRepo() {
+  return isInsideGitRepo();
+}
 
 // src/fingerprint/package-json.ts
 import fs4 from "fs";
@@ -554,6 +557,10 @@ import fs6 from "fs";
 import path7 from "path";
 function readExistingConfigs(dir) {
   const configs = {};
+  const readmeMdPath = path7.join(dir, "README.md");
+  if (fs6.existsSync(readmeMdPath)) {
+    configs.readmeMd = fs6.readFileSync(readmeMdPath, "utf-8");
+  }
   const claudeMdPath = path7.join(dir, "CLAUDE.md");
   if (fs6.existsSync(claudeMdPath)) {
     configs.claudeMd = fs6.readFileSync(claudeMdPath, "utf-8");
@@ -928,9 +935,9 @@ async function getValidToken() {
   }
   return refreshed;
 }
-async function apiRequest(path15, options = {}) {
+async function apiRequest(path18, options = {}) {
   let token = await getValidToken();
-  let resp = await fetch(`${API_URL}${path15}`, {
+  let resp = await fetch(`${API_URL}${path18}`, {
     method: options.method || "GET",
     headers: {
       "Content-Type": "application/json",
@@ -944,7 +951,7 @@ async function apiRequest(path15, options = {}) {
       throw new Error("Session expired. Run `caliber login` to re-authenticate.");
     }
     token = refreshed;
-    resp = await fetch(`${API_URL}${path15}`, {
+    resp = await fetch(`${API_URL}${path18}`, {
       method: options.method || "GET",
       headers: {
         "Content-Type": "application/json",
@@ -960,9 +967,9 @@ async function apiRequest(path15, options = {}) {
   const json = await resp.json();
   return json.data;
 }
-async function apiStream(path15, body, onChunk, onComplete, onError, onStatus) {
+async function apiStream(path18, body, onChunk, onComplete, onError, onStatus) {
   let token = await getValidToken();
-  let resp = await fetch(`${API_URL}${path15}`, {
+  let resp = await fetch(`${API_URL}${path18}`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -976,7 +983,7 @@ async function apiStream(path15, body, onChunk, onComplete, onError, onStatus) {
       throw new Error("Session expired. Run `caliber login` to re-authenticate.");
     }
     token = refreshed;
-    resp = await fetch(`${API_URL}${path15}`, {
+    resp = await fetch(`${API_URL}${path18}`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1215,6 +1222,101 @@ function ensureGitignore() {
   }
 }
 
+// src/lib/hooks.ts
+import fs13 from "fs";
+import path12 from "path";
+var SETTINGS_PATH = path12.join(".claude", "settings.json");
+var HOOK_COMMAND = "caliber refresh --quiet";
+function readSettings() {
+  if (!fs13.existsSync(SETTINGS_PATH)) return {};
+  try {
+    return JSON.parse(fs13.readFileSync(SETTINGS_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeSettings(settings) {
+  const dir = path12.dirname(SETTINGS_PATH);
+  if (!fs13.existsSync(dir)) fs13.mkdirSync(dir, { recursive: true });
+  fs13.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+}
+function findHookIndex(sessionEnd) {
+  return sessionEnd.findIndex(
+    (entry) => entry.hooks?.some((h) => h.command === HOOK_COMMAND)
+  );
+}
+function isHookInstalled() {
+  const settings = readSettings();
+  const sessionEnd = settings.hooks?.SessionEnd;
+  if (!Array.isArray(sessionEnd)) return false;
+  return findHookIndex(sessionEnd) !== -1;
+}
+function installHook() {
+  const settings = readSettings();
+  if (!settings.hooks) settings.hooks = {};
+  if (!Array.isArray(settings.hooks.SessionEnd)) settings.hooks.SessionEnd = [];
+  if (findHookIndex(settings.hooks.SessionEnd) !== -1) {
+    return { installed: false, alreadyInstalled: true };
+  }
+  settings.hooks.SessionEnd.push({
+    matcher: "",
+    hooks: [{ type: "command", command: HOOK_COMMAND }]
+  });
+  writeSettings(settings);
+  return { installed: true, alreadyInstalled: false };
+}
+function removeHook() {
+  const settings = readSettings();
+  const sessionEnd = settings.hooks?.SessionEnd;
+  if (!Array.isArray(sessionEnd)) {
+    return { removed: false, notFound: true };
+  }
+  const idx = findHookIndex(sessionEnd);
+  if (idx === -1) {
+    return { removed: false, notFound: true };
+  }
+  sessionEnd.splice(idx, 1);
+  if (sessionEnd.length === 0) {
+    delete settings.hooks.SessionEnd;
+  }
+  if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+  writeSettings(settings);
+  return { removed: true, notFound: false };
+}
+
+// src/lib/state.ts
+init_constants();
+import fs14 from "fs";
+import path13 from "path";
+import { execSync as execSync2 } from "child_process";
+var STATE_FILE = path13.join(CALIBER_DIR, ".caliber-state.json");
+function readState() {
+  try {
+    if (!fs14.existsSync(STATE_FILE)) return null;
+    return JSON.parse(fs14.readFileSync(STATE_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeState(state) {
+  if (!fs14.existsSync(CALIBER_DIR)) {
+    fs14.mkdirSync(CALIBER_DIR, { recursive: true });
+  }
+  fs14.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+function getCurrentHeadSha() {
+  try {
+    return execSync2("git rev-parse HEAD", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
 // src/utils/spinner-messages.ts
 var GENERATION_MESSAGES = [
   "Analyzing your project structure and dependencies...",
@@ -1441,6 +1543,21 @@ async function initCommand(options) {
     console.error(chalk2.red(err instanceof Error ? err.message : "Unknown error"));
     throw new Error("__exit__");
   }
+  const hookAnswer = await promptInput(chalk2.cyan("Enable auto-refresh on Claude Code session end? (Y/n):"));
+  if (!hookAnswer || hookAnswer.toLowerCase() !== "n") {
+    const hookResult = installHook();
+    if (hookResult.installed) {
+      console.log(`  ${chalk2.green("\u2713")} Auto-refresh hook installed`);
+      const sha = getCurrentHeadSha();
+      if (sha) {
+        writeState({ lastRefreshSha: sha, lastRefreshTimestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      }
+    } else if (hookResult.alreadyInstalled) {
+      console.log(chalk2.dim("  Auto-refresh hook already installed"));
+    }
+  } else {
+    console.log(chalk2.dim("  Skipped. Run `caliber hooks install` later to enable."));
+  }
   try {
     let projectId = existingProjectId;
     if (!projectId) {
@@ -1576,7 +1693,7 @@ function promptAction(explained) {
   });
 }
 function fileEntry(filePath, desc) {
-  const icon = fs13.existsSync(filePath) ? chalk2.yellow("~") : chalk2.green("+");
+  const icon = fs15.existsSync(filePath) ? chalk2.yellow("~") : chalk2.green("+");
   const description = desc ? chalk2.dim(`\u2014 ${desc}`) : "";
   return `  ${icon} ${filePath} ${description}`;
 }
@@ -1689,16 +1806,16 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk4 from "chalk";
-import fs15 from "fs";
+import fs17 from "fs";
 
 // src/scanner/index.ts
-import fs14 from "fs";
-import path12 from "path";
+import fs16 from "fs";
+import path14 from "path";
 import crypto4 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path12.join(dir, "CLAUDE.md");
-  if (fs14.existsSync(claudeMdPath)) {
+  const claudeMdPath = path14.join(dir, "CLAUDE.md");
+  if (fs16.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -1707,8 +1824,8 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const settingsPath = path12.join(dir, ".claude", "settings.json");
-  if (fs14.existsSync(settingsPath)) {
+  const settingsPath = path14.join(dir, ".claude", "settings.json");
+  if (fs16.existsSync(settingsPath)) {
     items.push({
       type: "config",
       platform: "claude",
@@ -1717,10 +1834,10 @@ function scanLocalState(dir) {
       path: settingsPath
     });
   }
-  const skillsDir = path12.join(dir, ".claude", "skills");
-  if (fs14.existsSync(skillsDir)) {
-    for (const file of fs14.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path12.join(skillsDir, file);
+  const skillsDir = path14.join(dir, ".claude", "skills");
+  if (fs16.existsSync(skillsDir)) {
+    for (const file of fs16.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path14.join(skillsDir, file);
       items.push({
         type: "skill",
         platform: "claude",
@@ -1730,10 +1847,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path12.join(dir, ".mcp.json");
-  if (fs14.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path14.join(dir, ".mcp.json");
+  if (fs16.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs14.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs16.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -1748,8 +1865,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path12.join(dir, ".cursorrules");
-  if (fs14.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path14.join(dir, ".cursorrules");
+  if (fs16.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -1758,10 +1875,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path12.join(dir, ".cursor", "rules");
-  if (fs14.existsSync(cursorRulesDir)) {
-    for (const file of fs14.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path12.join(cursorRulesDir, file);
+  const cursorRulesDir = path14.join(dir, ".cursor", "rules");
+  if (fs16.existsSync(cursorRulesDir)) {
+    for (const file of fs16.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path14.join(cursorRulesDir, file);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -1771,10 +1888,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorMcpPath = path12.join(dir, ".cursor", "mcp.json");
-  if (fs14.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path14.join(dir, ".cursor", "mcp.json");
+  if (fs16.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs14.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs16.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -1818,7 +1935,7 @@ function compareState(serverItems, localItems) {
   return { installed, missing, outdated, extra };
 }
 function hashFile(filePath) {
-  const content = fs14.readFileSync(filePath);
+  const content = fs16.readFileSync(filePath);
   return crypto4.createHash("sha256").update(content).digest("hex");
 }
 function hashContent(content) {
@@ -1850,7 +1967,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk4.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs15.existsSync(entry.path);
+    const exists = fs17.existsSync(entry.path);
     const icon = exists ? chalk4.green("\u2713") : chalk4.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -2401,10 +2518,243 @@ async function diffCommand(options) {
   }
 }
 
+// src/commands/refresh.ts
+import chalk11 from "chalk";
+import ora9 from "ora";
+
+// src/lib/git-diff.ts
+import { execSync as execSync3 } from "child_process";
+var MAX_DIFF_BYTES = 1e5;
+var DOC_PATTERNS = [
+  "CLAUDE.md",
+  "README.md",
+  ".cursorrules",
+  ".cursor/rules/",
+  ".claude/skills/"
+];
+function excludeArgs() {
+  return DOC_PATTERNS.flatMap((p) => ["--", `:!${p}`]);
+}
+function safeExec(cmd) {
+  try {
+    return execSync3(cmd, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      maxBuffer: 10 * 1024 * 1024
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function collectDiff(lastSha) {
+  let committedDiff = "";
+  let stagedDiff = "";
+  let unstagedDiff = "";
+  let changedFiles = [];
+  if (lastSha) {
+    committedDiff = safeExec(`git diff ${lastSha}..HEAD ${excludeArgs().join(" ")}`);
+    const committedFiles = safeExec(`git diff --name-only ${lastSha}..HEAD`);
+    if (committedFiles) {
+      changedFiles.push(...committedFiles.split("\n").filter(Boolean));
+    }
+  } else {
+    committedDiff = safeExec("git log --oneline -20");
+  }
+  stagedDiff = safeExec(`git diff --cached ${excludeArgs().join(" ")}`);
+  unstagedDiff = safeExec(`git diff ${excludeArgs().join(" ")}`);
+  const stagedFiles = safeExec("git diff --cached --name-only");
+  if (stagedFiles) {
+    changedFiles.push(...stagedFiles.split("\n").filter(Boolean));
+  }
+  const unstagedFiles = safeExec("git diff --name-only");
+  if (unstagedFiles) {
+    changedFiles.push(...unstagedFiles.split("\n").filter(Boolean));
+  }
+  changedFiles = [...new Set(changedFiles)].filter(
+    (f) => !DOC_PATTERNS.some((p) => f === p || f.startsWith(p))
+  );
+  const totalSize = committedDiff.length + stagedDiff.length + unstagedDiff.length;
+  if (totalSize > MAX_DIFF_BYTES) {
+    const ratio = MAX_DIFF_BYTES / totalSize;
+    committedDiff = committedDiff.slice(0, Math.floor(committedDiff.length * ratio));
+    stagedDiff = stagedDiff.slice(0, Math.floor(stagedDiff.length * ratio));
+    unstagedDiff = unstagedDiff.slice(0, Math.floor(unstagedDiff.length * ratio));
+  }
+  const hasChanges = !!(committedDiff || stagedDiff || unstagedDiff || changedFiles.length);
+  const parts = [];
+  if (changedFiles.length) parts.push(`${changedFiles.length} files changed`);
+  if (committedDiff) parts.push("committed changes");
+  if (stagedDiff) parts.push("staged changes");
+  if (unstagedDiff) parts.push("unstaged changes");
+  const summary = parts.join(", ") || "no changes";
+  return { hasChanges, committedDiff, stagedDiff, unstagedDiff, changedFiles, summary };
+}
+
+// src/writers/refresh.ts
+import fs18 from "fs";
+import path15 from "path";
+function writeRefreshDocs(docs) {
+  const written = [];
+  if (docs.claudeMd) {
+    fs18.writeFileSync("CLAUDE.md", docs.claudeMd);
+    written.push("CLAUDE.md");
+  }
+  if (docs.readmeMd) {
+    fs18.writeFileSync("README.md", docs.readmeMd);
+    written.push("README.md");
+  }
+  if (docs.cursorrules) {
+    fs18.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 });
+    for (const rule of docs.cursorRules) {
+      const filePath = path15.join(rulesDir, rule.filename);
+      fs18.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 });
+    for (const skill of docs.claudeSkills) {
+      const filePath = path15.join(skillsDir, skill.filename);
+      fs18.writeFileSync(filePath, skill.content);
+      written.push(filePath);
+    }
+  }
+  return written;
+}
+
+// src/commands/refresh.ts
+function log(quiet, ...args) {
+  if (!quiet) console.log(...args);
+}
+async function refreshCommand(options) {
+  const quiet = !!options.quiet;
+  try {
+    const auth2 = getStoredAuth();
+    if (!auth2) {
+      if (quiet) return;
+      console.log(chalk11.red("Not authenticated. Run `caliber login` first."));
+      throw new Error("__exit__");
+    }
+    if (!isGitRepo()) {
+      if (quiet) return;
+      console.log(chalk11.red("Not inside a git repository."));
+      throw new Error("__exit__");
+    }
+    const state = readState();
+    const lastSha = state?.lastRefreshSha ?? null;
+    const diff = collectDiff(lastSha);
+    const currentSha = getCurrentHeadSha();
+    if (!diff.hasChanges) {
+      if (currentSha) {
+        writeState({ lastRefreshSha: currentSha, lastRefreshTimestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      }
+      log(quiet, chalk11.dim("No changes since last refresh."));
+      return;
+    }
+    const spinner = quiet ? null : ora9("Analyzing changes...").start();
+    const existingDocs = readExistingConfigs(process.cwd());
+    const fingerprint = collectFingerprint(process.cwd());
+    const projectContext = {
+      languages: fingerprint.languages,
+      frameworks: fingerprint.frameworks,
+      packageName: fingerprint.packageName
+    };
+    const response = await apiRequest("/api/setups/refresh", {
+      method: "POST",
+      body: {
+        diff: {
+          committed: diff.committedDiff,
+          staged: diff.stagedDiff,
+          unstaged: diff.unstagedDiff,
+          changedFiles: diff.changedFiles,
+          summary: diff.summary
+        },
+        existingDocs,
+        projectContext
+      }
+    });
+    if (!response.docsUpdated || response.docsUpdated.length === 0) {
+      spinner?.succeed("No doc updates needed");
+      if (currentSha) {
+        writeState({ lastRefreshSha: currentSha, lastRefreshTimestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      }
+      return;
+    }
+    if (options.dryRun) {
+      spinner?.info("Dry run \u2014 would update:");
+      for (const doc of response.docsUpdated) {
+        console.log(`  ${chalk11.yellow("~")} ${doc}`);
+      }
+      if (response.changesSummary) {
+        console.log(chalk11.dim(`
+  ${response.changesSummary}`));
+      }
+      return;
+    }
+    const written = writeRefreshDocs(response.updatedDocs);
+    spinner?.succeed(`Updated ${written.length} doc${written.length === 1 ? "" : "s"}`);
+    for (const file of written) {
+      log(quiet, `  ${chalk11.green("\u2713")} ${file}`);
+    }
+    if (response.changesSummary) {
+      log(quiet, chalk11.dim(`
+  ${response.changesSummary}`));
+    }
+    if (currentSha) {
+      writeState({ lastRefreshSha: currentSha, lastRefreshTimestamp: (/* @__PURE__ */ new Date()).toISOString() });
+    }
+    trackEvent("refresh_completed", {
+      docs_updated: written.length,
+      changed_files: diff.changedFiles.length
+    });
+  } catch (err) {
+    if (err instanceof Error && err.message === "__exit__") throw err;
+    if (quiet) return;
+    const msg = err instanceof Error ? err.message : "Unknown error";
+    console.log(chalk11.red(`Refresh failed: ${msg}`));
+    throw new Error("__exit__");
+  }
+}
+
+// src/commands/hooks.ts
+import chalk12 from "chalk";
+async function hooksInstallCommand() {
+  const result = installHook();
+  if (result.alreadyInstalled) {
+    console.log(chalk12.dim("Hook already installed."));
+    return;
+  }
+  console.log(chalk12.green("\u2713") + " SessionEnd hook installed in .claude/settings.json");
+  console.log(chalk12.dim("  Docs will auto-refresh when Claude Code sessions end."));
+}
+async function hooksRemoveCommand() {
+  const result = removeHook();
+  if (result.notFound) {
+    console.log(chalk12.dim("Hook not found."));
+    return;
+  }
+  console.log(chalk12.green("\u2713") + " SessionEnd hook removed from .claude/settings.json");
+}
+async function hooksStatusCommand() {
+  const installed = isHookInstalled();
+  if (installed) {
+    console.log(chalk12.green("\u2713") + " Auto-refresh hook is " + chalk12.green("installed"));
+  } else {
+    console.log(chalk12.dim("\u2717") + " Auto-refresh hook is " + chalk12.yellow("not installed"));
+    console.log(chalk12.dim("  Run `caliber hooks install` to enable auto-refresh on session end."));
+  }
+}
+
 // src/cli.ts
-var __dirname2 = path13.dirname(fileURLToPath3(import.meta.url));
+var __dirname2 = path16.dirname(fileURLToPath3(import.meta.url));
 var pkg3 = JSON.parse(
-  fs16.readFileSync(path13.resolve(__dirname2, "..", "package.json"), "utf-8")
+  fs19.readFileSync(path16.resolve(__dirname2, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 program.name("caliber").description("Configure your coding agent environment").version(pkg3.version);
@@ -2418,23 +2768,28 @@ program.command("recommend").description("Discover and manage skill recommendati
 program.command("health").description("Analyze context health and quality").option("--fix", "Generate and execute a fix plan").option("--json", "Output as JSON").action(healthCommand);
 program.command("sync").description("Sync local config with server state").option("--platform <platform>", "Target platform: claude, cursor, or both").option("--dry-run", "Preview changes without writing files").action(syncCommand);
 program.command("diff").description("Compare local config with server state").option("--platform <platform>", "Target platform: claude, cursor, or both").action(diffCommand);
+program.command("refresh").description("Update docs based on recent code changes").option("--quiet", "Suppress output (for use in hooks)").option("--dry-run", "Preview changes without writing files").action(refreshCommand);
+var hooks = program.command("hooks").description("Manage Claude Code session hooks");
+hooks.command("install").description("Install auto-refresh SessionEnd hook").action(hooksInstallCommand);
+hooks.command("remove").description("Remove auto-refresh SessionEnd hook").action(hooksRemoveCommand);
+hooks.command("status").description("Check if auto-refresh hook is installed").action(hooksStatusCommand);
 
 // src/utils/version-check.ts
-import fs17 from "fs";
-import path14 from "path";
+import fs20 from "fs";
+import path17 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import readline3 from "readline";
-import { execSync as execSync2 } from "child_process";
-import chalk11 from "chalk";
-import ora9 from "ora";
-var __dirname_vc = path14.dirname(fileURLToPath4(import.meta.url));
+import { execSync as execSync4 } from "child_process";
+import chalk13 from "chalk";
+import ora10 from "ora";
+var __dirname_vc = path17.dirname(fileURLToPath4(import.meta.url));
 var pkg4 = JSON.parse(
-  fs17.readFileSync(path14.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs20.readFileSync(path17.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function promptYesNo(question) {
   const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve2) => {
-    rl.question(chalk11.cyan(`${question} `), (answer) => {
+    rl.question(chalk13.cyan(`${question} `), (answer) => {
       rl.close();
       const normalized = answer.trim().toLowerCase();
       resolve2(normalized === "" || normalized === "y" || normalized === "yes");
@@ -2458,17 +2813,17 @@ async function checkForUpdates() {
     const isInteractive = process.stdin.isTTY === true;
     if (!isInteractive) {
       console.log(
-        chalk11.yellow(
+        chalk13.yellow(
           `
 Update available: ${current} -> ${latest}
-Run ${chalk11.bold("npm install -g @caliber-ai/cli")} to upgrade.
+Run ${chalk13.bold("npm install -g @caliber-ai/cli")} to upgrade.
 `
         )
       );
       return;
     }
     console.log(
-      chalk11.yellow(`
+      chalk13.yellow(`
 Update available: ${current} -> ${latest}`)
     );
     const shouldUpdate = await promptYesNo("Would you like to update now? (Y/n)");
@@ -2476,23 +2831,23 @@ Update available: ${current} -> ${latest}`)
       console.log();
       return;
     }
-    const spinner = ora9("Updating @caliber-ai/cli...").start();
+    const spinner = ora10("Updating @caliber-ai/cli...").start();
     try {
-      execSync2("npm install -g @caliber-ai/cli", { stdio: "pipe" });
-      spinner.succeed(chalk11.green(`Updated to ${latest}`));
+      execSync4("npm install -g @caliber-ai/cli", { stdio: "pipe" });
+      spinner.succeed(chalk13.green(`Updated to ${latest}`));
       const args = process.argv.slice(2);
-      console.log(chalk11.dim(`
+      console.log(chalk13.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
-      execSync2(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
+      execSync4(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
         stdio: "inherit"
       });
       process.exit(0);
     } catch {
       spinner.fail("Update failed");
       console.log(
-        chalk11.yellow(
-          `Run ${chalk11.bold("npm install -g @caliber-ai/cli")} manually to upgrade.
+        chalk13.yellow(
+          `Run ${chalk13.bold("npm install -g @caliber-ai/cli")} manually to upgrade.
 `
         )
       );