@rely-ai/caliber 1.7.4 → 1.7.5

package/dist/bin.js

@@ -165,7 +165,7 @@ var init_constants = __esm({
 
 // src/cli.ts
 import { Command } from "commander";
-import fs28 from "fs";
+import fs29 from "fs";
 import path22 from "path";
 import { fileURLToPath } from "url";
 
@@ -175,7 +175,7 @@ import ora2 from "ora";
 import readline3 from "readline";
 import select5 from "@inquirer/select";
 import checkbox from "@inquirer/checkbox";
-import fs22 from "fs";
+import fs23 from "fs";
 
 // src/fingerprint/index.ts
 import fs6 from "fs";
@@ -2670,28 +2670,64 @@ ${agentRefs.join(" ")}
 }
 
 // src/lib/hooks.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import path12 from "path";
+import { execSync as execSync6 } from "child_process";
+
+// src/lib/resolve-caliber.ts
+import fs16 from "fs";
 import { execSync as execSync5 } from "child_process";
+var _resolved = null;
+function resolveCaliber() {
+  if (_resolved) return _resolved;
+  try {
+    const found = execSync5("which caliber", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (found) {
+      _resolved = found;
+      return _resolved;
+    }
+  } catch {
+  }
+  const binPath = process.argv[1];
+  if (binPath && fs16.existsSync(binPath)) {
+    _resolved = binPath;
+    return _resolved;
+  }
+  _resolved = "caliber";
+  return _resolved;
+}
+function isCaliberCommand(command, subcommandTail) {
+  if (command === `caliber ${subcommandTail}`) return true;
+  if (command.endsWith(`/caliber ${subcommandTail}`)) return true;
+  return false;
+}
+
+// src/lib/hooks.ts
 var SETTINGS_PATH = path12.join(".claude", "settings.json");
-var HOOK_COMMAND = "caliber refresh --quiet";
+var REFRESH_TAIL = "refresh --quiet";
 var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
+function getHookCommand() {
+  return `${resolveCaliber()} ${REFRESH_TAIL}`;
+}
 function readSettings() {
-  if (!fs16.existsSync(SETTINGS_PATH)) return {};
+  if (!fs17.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs16.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs17.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
   const dir = path12.dirname(SETTINGS_PATH);
-  if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
-  fs16.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
+  fs17.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
-    (entry) => entry.hooks?.some((h) => h.command === HOOK_COMMAND)
+    (entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, REFRESH_TAIL))
   );
 }
 function isHookInstalled() {
@@ -2709,7 +2745,7 @@ function installHook() {
   }
   settings.hooks.SessionEnd.push({
     matcher: "",
-    hooks: [{ type: "command", command: HOOK_COMMAND, description: HOOK_DESCRIPTION }]
+    hooks: [{ type: "command", command: getHookCommand(), description: HOOK_DESCRIPTION }]
   });
   writeSettings(settings);
   return { installed: true, alreadyInstalled: false };
@@ -2736,16 +2772,19 @@ function removeHook() {
 }
 var PRECOMMIT_START = "# caliber:pre-commit:start";
 var PRECOMMIT_END = "# caliber:pre-commit:end";
-var PRECOMMIT_BLOCK = `${PRECOMMIT_START}
-if command -v caliber >/dev/null 2>&1; then
+function getPrecommitBlock() {
+  const bin = resolveCaliber();
+  return `${PRECOMMIT_START}
+if [ -x "${bin}" ] || command -v "${bin}" >/dev/null 2>&1; then
   echo "\\033[2mcaliber: refreshing docs...\\033[0m"
-  caliber refresh 2>/dev/null || true
+  "${bin}" refresh 2>/dev/null || true
   git diff --name-only -- CLAUDE.md .claude/ .cursor/ AGENTS.md 2>/dev/null | xargs git add 2>/dev/null || true
 fi
 ${PRECOMMIT_END}`;
+}
 function getGitHooksDir() {
   try {
-    const gitDir = execSync5("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const gitDir = execSync6("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     return path12.join(gitDir, "hooks");
   } catch {
     return null;
@@ -2757,8 +2796,8 @@ function getPreCommitPath() {
 }
 function isPreCommitHookInstalled() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs16.existsSync(hookPath)) return false;
-  const content = fs16.readFileSync(hookPath, "utf-8");
+  if (!hookPath || !fs17.existsSync(hookPath)) return false;
+  const content = fs17.readFileSync(hookPath, "utf-8");
   return content.includes(PRECOMMIT_START);
 }
 function installPreCommitHook() {
@@ -2768,81 +2807,78 @@ function installPreCommitHook() {
   const hookPath = getPreCommitPath();
   if (!hookPath) return { installed: false, alreadyInstalled: false };
   const hooksDir = path12.dirname(hookPath);
-  if (!fs16.existsSync(hooksDir)) fs16.mkdirSync(hooksDir, { recursive: true });
+  if (!fs17.existsSync(hooksDir)) fs17.mkdirSync(hooksDir, { recursive: true });
   let content = "";
-  if (fs16.existsSync(hookPath)) {
-    content = fs16.readFileSync(hookPath, "utf-8");
+  if (fs17.existsSync(hookPath)) {
+    content = fs17.readFileSync(hookPath, "utf-8");
     if (!content.endsWith("\n")) content += "\n";
-    content += "\n" + PRECOMMIT_BLOCK + "\n";
+    content += "\n" + getPrecommitBlock() + "\n";
   } else {
-    content = "#!/bin/sh\n\n" + PRECOMMIT_BLOCK + "\n";
+    content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
   }
-  fs16.writeFileSync(hookPath, content);
-  fs16.chmodSync(hookPath, 493);
+  fs17.writeFileSync(hookPath, content);
+  fs17.chmodSync(hookPath, 493);
   return { installed: true, alreadyInstalled: false };
 }
 function removePreCommitHook() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs16.existsSync(hookPath)) {
+  if (!hookPath || !fs17.existsSync(hookPath)) {
     return { removed: false, notFound: true };
   }
-  let content = fs16.readFileSync(hookPath, "utf-8");
+  let content = fs17.readFileSync(hookPath, "utf-8");
   if (!content.includes(PRECOMMIT_START)) {
     return { removed: false, notFound: true };
   }
   const regex = new RegExp(`\\n?${PRECOMMIT_START}[\\s\\S]*?${PRECOMMIT_END}\\n?`);
   content = content.replace(regex, "\n");
   if (content.trim() === "#!/bin/sh" || content.trim() === "") {
-    fs16.unlinkSync(hookPath);
+    fs17.unlinkSync(hookPath);
   } else {
-    fs16.writeFileSync(hookPath, content);
+    fs17.writeFileSync(hookPath, content);
   }
   return { removed: true, notFound: false };
 }
 
 // src/lib/learning-hooks.ts
-import fs17 from "fs";
+import fs18 from "fs";
 import path13 from "path";
 var SETTINGS_PATH2 = path13.join(".claude", "settings.json");
-var HOOK_CONFIGS = [
-  {
-    event: "PostToolUse",
-    command: "caliber learn observe",
-    description: "Caliber: recording tool usage for session learning"
-  },
-  {
-    event: "PostToolUseFailure",
-    command: "caliber learn observe --failure",
-    description: "Caliber: recording tool failure for session learning"
-  },
-  {
-    event: "SessionEnd",
-    command: "caliber learn finalize",
-    description: "Caliber: finalizing session learnings"
-  }
+var HOOK_TAILS = [
+  { event: "PostToolUse", tail: "learn observe", description: "Caliber: recording tool usage for session learning" },
+  { event: "PostToolUseFailure", tail: "learn observe --failure", description: "Caliber: recording tool failure for session learning" },
+  { event: "SessionEnd", tail: "learn finalize", description: "Caliber: finalizing session learnings" }
 ];
+function getHookConfigs() {
+  const bin = resolveCaliber();
+  return HOOK_TAILS.map(({ event, tail, description }) => ({
+    event,
+    command: `${bin} ${tail}`,
+    tail,
+    description
+  }));
+}
 function readSettings2() {
-  if (!fs17.existsSync(SETTINGS_PATH2)) return {};
+  if (!fs18.existsSync(SETTINGS_PATH2)) return {};
   try {
-    return JSON.parse(fs17.readFileSync(SETTINGS_PATH2, "utf-8"));
+    return JSON.parse(fs18.readFileSync(SETTINGS_PATH2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings2(settings) {
   const dir = path13.dirname(SETTINGS_PATH2);
-  if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
-  fs17.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
+  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
+  fs18.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
 }
-function hasLearningHook(matchers, command) {
-  return matchers.some((entry) => entry.hooks?.some((h) => h.command === command));
+function hasLearningHook(matchers, tail) {
+  return matchers.some((entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, tail)));
 }
 function areLearningHooksInstalled() {
   const settings = readSettings2();
   if (!settings.hooks) return false;
-  return HOOK_CONFIGS.every((cfg) => {
+  return HOOK_TAILS.every((cfg) => {
     const matchers = settings.hooks[cfg.event];
-    return Array.isArray(matchers) && hasLearningHook(matchers, cfg.command);
+    return Array.isArray(matchers) && hasLearningHook(matchers, cfg.tail);
   });
 }
 function installLearningHooks() {
@@ -2851,11 +2887,12 @@ function installLearningHooks() {
   }
   const settings = readSettings2();
   if (!settings.hooks) settings.hooks = {};
-  for (const cfg of HOOK_CONFIGS) {
+  const configs = getHookConfigs();
+  for (const cfg of configs) {
     if (!Array.isArray(settings.hooks[cfg.event])) {
       settings.hooks[cfg.event] = [];
     }
-    if (!hasLearningHook(settings.hooks[cfg.event], cfg.command)) {
+    if (!hasLearningHook(settings.hooks[cfg.event], cfg.tail)) {
       settings.hooks[cfg.event].push({
         matcher: "",
         hooks: [{ type: "command", command: cfg.command, description: cfg.description }]
@@ -2869,10 +2906,10 @@ function removeLearningHooks() {
   const settings = readSettings2();
   if (!settings.hooks) return { removed: false, notFound: true };
   let removedAny = false;
-  for (const cfg of HOOK_CONFIGS) {
+  for (const cfg of HOOK_TAILS) {
     const matchers = settings.hooks[cfg.event];
     if (!Array.isArray(matchers)) continue;
-    const idx = matchers.findIndex((entry) => entry.hooks?.some((h) => h.command === cfg.command));
+    const idx = matchers.findIndex((entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, cfg.tail)));
     if (idx !== -1) {
       matchers.splice(idx, 1);
       removedAny = true;
@@ -2889,9 +2926,9 @@ function removeLearningHooks() {
 
 // src/lib/state.ts
 init_constants();
-import fs18 from "fs";
+import fs19 from "fs";
 import path14 from "path";
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync7 } from "child_process";
 var STATE_FILE = path14.join(CALIBER_DIR, ".caliber-state.json");
 function normalizeTargetAgent(value) {
   if (Array.isArray(value)) return value;
@@ -2903,8 +2940,8 @@ function normalizeTargetAgent(value) {
 }
 function readState() {
   try {
-    if (!fs18.existsSync(STATE_FILE)) return null;
-    const raw = JSON.parse(fs18.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs19.existsSync(STATE_FILE)) return null;
+    const raw = JSON.parse(fs19.readFileSync(STATE_FILE, "utf-8"));
     if (raw.targetAgent) raw.targetAgent = normalizeTargetAgent(raw.targetAgent);
     return raw;
   } catch {
@@ -2912,14 +2949,14 @@ function readState() {
   }
 }
 function writeState(state) {
-  if (!fs18.existsSync(CALIBER_DIR)) {
-    fs18.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs19.existsSync(CALIBER_DIR)) {
+    fs19.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs18.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs19.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
-    return execSync6("git rev-parse HEAD", {
+    return execSync7("git rev-parse HEAD", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -4041,7 +4078,7 @@ function checkFreshness(dir) {
 
 // src/scoring/checks/bonus.ts
 import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync4 } from "fs";
-import { execSync as execSync7 } from "child_process";
+import { execSync as execSync8 } from "child_process";
 import { join as join6 } from "path";
 function readFileOrNull5(path24) {
   try {
@@ -4052,7 +4089,7 @@ function readFileOrNull5(path24) {
 }
 function hasPreCommitHook(dir) {
   try {
-    const gitDir = execSync7("git rev-parse --git-dir", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const gitDir = execSync8("git rev-parse --git-dir", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     const hookPath = join6(gitDir, "hooks", "pre-commit");
     const content = readFileOrNull5(hookPath);
     return content ? content.includes("caliber") : false;
@@ -4140,22 +4177,22 @@ function checkBonus(dir) {
 
 // src/scoring/dismissed.ts
 init_constants();
-import fs19 from "fs";
+import fs20 from "fs";
 import path15 from "path";
 var DISMISSED_FILE = path15.join(CALIBER_DIR, "dismissed-checks.json");
 function readDismissedChecks() {
   try {
-    if (!fs19.existsSync(DISMISSED_FILE)) return [];
-    return JSON.parse(fs19.readFileSync(DISMISSED_FILE, "utf-8"));
+    if (!fs20.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs20.readFileSync(DISMISSED_FILE, "utf-8"));
   } catch {
     return [];
   }
 }
 function writeDismissedChecks(checks) {
-  if (!fs19.existsSync(CALIBER_DIR)) {
-    fs19.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs20.existsSync(CALIBER_DIR)) {
+    fs20.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs19.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+  fs20.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
 }
 function getDismissedIds() {
   return new Set(readDismissedChecks().map((c) => c.id));
@@ -4350,13 +4387,13 @@ import { mkdirSync, readFileSync as readFileSync7, readdirSync as readdirSync5,
 import { join as join8, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
-import fs20 from "fs";
+import fs21 from "fs";
 import path16 from "path";
 import crypto2 from "crypto";
 function scanLocalState(dir) {
   const items = [];
   const claudeMdPath = path16.join(dir, "CLAUDE.md");
-  if (fs20.existsSync(claudeMdPath)) {
+  if (fs21.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -4366,8 +4403,8 @@ function scanLocalState(dir) {
     });
   }
   const skillsDir = path16.join(dir, ".claude", "skills");
-  if (fs20.existsSync(skillsDir)) {
-    for (const file of fs20.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+  if (fs21.existsSync(skillsDir)) {
+    for (const file of fs21.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
       const filePath = path16.join(skillsDir, file);
       items.push({
         type: "skill",
@@ -4379,9 +4416,9 @@ function scanLocalState(dir) {
     }
   }
   const mcpJsonPath = path16.join(dir, ".mcp.json");
-  if (fs20.existsSync(mcpJsonPath)) {
+  if (fs21.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs20.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs21.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -4397,7 +4434,7 @@ function scanLocalState(dir) {
     }
   }
   const agentsMdPath = path16.join(dir, "AGENTS.md");
-  if (fs20.existsSync(agentsMdPath)) {
+  if (fs21.existsSync(agentsMdPath)) {
     items.push({
       type: "rule",
       platform: "codex",
@@ -4407,11 +4444,11 @@ function scanLocalState(dir) {
     });
   }
   const codexSkillsDir = path16.join(dir, ".agents", "skills");
-  if (fs20.existsSync(codexSkillsDir)) {
+  if (fs21.existsSync(codexSkillsDir)) {
     try {
-      for (const name of fs20.readdirSync(codexSkillsDir)) {
+      for (const name of fs21.readdirSync(codexSkillsDir)) {
         const skillFile = path16.join(codexSkillsDir, name, "SKILL.md");
-        if (fs20.existsSync(skillFile)) {
+        if (fs21.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "codex",
@@ -4425,7 +4462,7 @@ function scanLocalState(dir) {
     }
   }
   const cursorrulesPath = path16.join(dir, ".cursorrules");
-  if (fs20.existsSync(cursorrulesPath)) {
+  if (fs21.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -4435,8 +4472,8 @@ function scanLocalState(dir) {
     });
   }
   const cursorRulesDir = path16.join(dir, ".cursor", "rules");
-  if (fs20.existsSync(cursorRulesDir)) {
-    for (const file of fs20.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+  if (fs21.existsSync(cursorRulesDir)) {
+    for (const file of fs21.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
       const filePath = path16.join(cursorRulesDir, file);
       items.push({
         type: "rule",
@@ -4448,11 +4485,11 @@ function scanLocalState(dir) {
     }
   }
   const cursorSkillsDir = path16.join(dir, ".cursor", "skills");
-  if (fs20.existsSync(cursorSkillsDir)) {
+  if (fs21.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs20.readdirSync(cursorSkillsDir)) {
+      for (const name of fs21.readdirSync(cursorSkillsDir)) {
         const skillFile = path16.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs20.existsSync(skillFile)) {
+        if (fs21.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -4466,9 +4503,9 @@ function scanLocalState(dir) {
     }
   }
   const cursorMcpPath = path16.join(dir, ".cursor", "mcp.json");
-  if (fs20.existsSync(cursorMcpPath)) {
+  if (fs21.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs20.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs21.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -4486,7 +4523,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs20.readFileSync(filePath, "utf-8");
+  const text = fs21.readFileSync(filePath, "utf-8");
   return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -4501,27 +4538,27 @@ import { PostHog } from "posthog-node";
 import chalk6 from "chalk";
 
 // src/telemetry/config.ts
-import fs21 from "fs";
+import fs22 from "fs";
 import path17 from "path";
 import os3 from "os";
 import crypto3 from "crypto";
-import { execSync as execSync8 } from "child_process";
+import { execSync as execSync9 } from "child_process";
 var CONFIG_DIR2 = path17.join(os3.homedir(), ".caliber");
 var CONFIG_FILE2 = path17.join(CONFIG_DIR2, "config.json");
 var runtimeDisabled = false;
 function readConfig() {
   try {
-    if (!fs21.existsSync(CONFIG_FILE2)) return {};
-    return JSON.parse(fs21.readFileSync(CONFIG_FILE2, "utf-8"));
+    if (!fs22.existsSync(CONFIG_FILE2)) return {};
+    return JSON.parse(fs22.readFileSync(CONFIG_FILE2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
-  if (!fs21.existsSync(CONFIG_DIR2)) {
-    fs21.mkdirSync(CONFIG_DIR2, { recursive: true });
+  if (!fs22.existsSync(CONFIG_DIR2)) {
+    fs22.mkdirSync(CONFIG_DIR2, { recursive: true });
   }
-  fs21.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  fs22.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function getMachineId() {
   const config = readConfig();
@@ -4532,7 +4569,7 @@ function getMachineId() {
 }
 function getGitEmailHash() {
   try {
-    const email = execSync8("git config user.email", { encoding: "utf-8" }).trim();
+    const email = execSync9("git config user.email", { encoding: "utf-8" }).trim();
     if (!email) return void 0;
     return crypto3.createHash("sha256").update(email).digest("hex");
   } catch {
@@ -5738,7 +5775,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs22.existsSync("CLAUDE.md") ? chalk8.yellow("~") : chalk8.green("+");
+      const icon = fs23.existsSync("CLAUDE.md") ? chalk8.yellow("~") : chalk8.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk8.bold("CLAUDE.md")}`);
       if (desc) console.log(chalk8.dim(`    ${desc}`));
@@ -5748,7 +5785,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(skills) && skills.length > 0) {
       for (const skill of skills) {
         const skillPath = `.claude/skills/${skill.name}/SKILL.md`;
-        const icon = fs22.existsSync(skillPath) ? chalk8.yellow("~") : chalk8.green("+");
+        const icon = fs23.existsSync(skillPath) ? chalk8.yellow("~") : chalk8.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk8.bold(skillPath)}`);
         console.log(chalk8.dim(`    ${desc || skill.description || skill.name}`));
@@ -5759,7 +5796,7 @@ function printSetupSummary(setup) {
   const codex = setup.codex;
   if (codex) {
     if (codex.agentsMd) {
-      const icon = fs22.existsSync("AGENTS.md") ? chalk8.yellow("~") : chalk8.green("+");
+      const icon = fs23.existsSync("AGENTS.md") ? chalk8.yellow("~") : chalk8.green("+");
       const desc = getDescription("AGENTS.md");
       console.log(`  ${icon} ${chalk8.bold("AGENTS.md")}`);
       if (desc) console.log(chalk8.dim(`    ${desc}`));
@@ -5769,7 +5806,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(codexSkills) && codexSkills.length > 0) {
       for (const skill of codexSkills) {
         const skillPath = `.agents/skills/${skill.name}/SKILL.md`;
-        const icon = fs22.existsSync(skillPath) ? chalk8.yellow("~") : chalk8.green("+");
+        const icon = fs23.existsSync(skillPath) ? chalk8.yellow("~") : chalk8.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk8.bold(skillPath)}`);
         console.log(chalk8.dim(`    ${desc || skill.description || skill.name}`));
@@ -5779,7 +5816,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs22.existsSync(".cursorrules") ? chalk8.yellow("~") : chalk8.green("+");
+      const icon = fs23.existsSync(".cursorrules") ? chalk8.yellow("~") : chalk8.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk8.bold(".cursorrules")}`);
       if (desc) console.log(chalk8.dim(`    ${desc}`));
@@ -5789,7 +5826,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(cursorSkills) && cursorSkills.length > 0) {
       for (const skill of cursorSkills) {
         const skillPath = `.cursor/skills/${skill.name}/SKILL.md`;
-        const icon = fs22.existsSync(skillPath) ? chalk8.yellow("~") : chalk8.green("+");
+        const icon = fs23.existsSync(skillPath) ? chalk8.yellow("~") : chalk8.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk8.bold(skillPath)}`);
         console.log(chalk8.dim(`    ${desc || skill.description || skill.name}`));
@@ -5800,7 +5837,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rules) && rules.length > 0) {
       for (const rule of rules) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs22.existsSync(rulePath) ? chalk8.yellow("~") : chalk8.green("+");
+        const icon = fs23.existsSync(rulePath) ? chalk8.yellow("~") : chalk8.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk8.bold(rulePath)}`);
         if (desc) {
@@ -5813,7 +5850,7 @@ function printSetupSummary(setup) {
       }
     }
   }
-  if (!codex && !fs22.existsSync("AGENTS.md")) {
+  if (!codex && !fs23.existsSync("AGENTS.md")) {
     console.log(`  ${chalk8.green("+")} ${chalk8.bold("AGENTS.md")}`);
     console.log(chalk8.dim("    Cross-agent coordination file"));
     console.log("");
@@ -5832,8 +5869,8 @@ function ensurePermissions() {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs22.existsSync(settingsPath)) {
-      settings = JSON.parse(fs22.readFileSync(settingsPath, "utf-8"));
+    if (fs23.existsSync(settingsPath)) {
+      settings = JSON.parse(fs23.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -5847,8 +5884,8 @@ function ensurePermissions() {
     "Bash(git *)"
   ];
   settings.permissions = permissions;
-  if (!fs22.existsSync(".claude")) fs22.mkdirSync(".claude", { recursive: true });
-  fs22.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs23.existsSync(".claude")) fs23.mkdirSync(".claude", { recursive: true });
+  fs23.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 
 // src/commands/undo.ts
@@ -5885,7 +5922,7 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk10 from "chalk";
-import fs23 from "fs";
+import fs24 from "fs";
 init_config();
 async function statusCommand(options) {
   const config = loadConfig();
@@ -5912,7 +5949,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk10.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs23.existsSync(entry.path);
+    const exists = fs24.existsSync(entry.path);
     const icon = exists ? chalk10.green("\u2713") : chalk10.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -6093,13 +6130,13 @@ async function scoreCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs25 from "fs";
+import fs26 from "fs";
 import path19 from "path";
 import chalk13 from "chalk";
 import ora5 from "ora";
 
 // src/lib/git-diff.ts
-import { execSync as execSync9 } from "child_process";
+import { execSync as execSync10 } from "child_process";
 var MAX_DIFF_BYTES = 1e5;
 var DOC_PATTERNS = [
   "CLAUDE.md",
@@ -6113,7 +6150,7 @@ function excludeArgs() {
 }
 function safeExec(cmd) {
   try {
-    return execSync9(cmd, {
+    return execSync10(cmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       maxBuffer: 10 * 1024 * 1024
@@ -6171,37 +6208,37 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs24 from "fs";
+import fs25 from "fs";
 import path18 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs24.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs25.writeFileSync("CLAUDE.md", docs.claudeMd);
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs24.writeFileSync("README.md", docs.readmeMd);
+    fs25.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs24.writeFileSync(".cursorrules", docs.cursorrules);
+    fs25.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
     const rulesDir = path18.join(".cursor", "rules");
-    if (!fs24.existsSync(rulesDir)) fs24.mkdirSync(rulesDir, { recursive: true });
+    if (!fs25.existsSync(rulesDir)) fs25.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
       const filePath = path18.join(rulesDir, rule.filename);
-      fs24.writeFileSync(filePath, rule.content);
+      fs25.writeFileSync(filePath, rule.content);
       written.push(filePath);
     }
   }
   if (docs.claudeSkills) {
     const skillsDir = path18.join(".claude", "skills");
-    if (!fs24.existsSync(skillsDir)) fs24.mkdirSync(skillsDir, { recursive: true });
+    if (!fs25.existsSync(skillsDir)) fs25.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
       const filePath = path18.join(skillsDir, skill.filename);
-      fs24.writeFileSync(filePath, skill.content);
+      fs25.writeFileSync(filePath, skill.content);
       written.push(filePath);
     }
   }
@@ -6280,11 +6317,11 @@ function log(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs25.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs26.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       const childPath = path19.join(parentDir, entry.name);
-      if (fs25.existsSync(path19.join(childPath, ".git"))) {
+      if (fs26.existsSync(path19.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -6636,7 +6673,7 @@ function readStdin() {
 
 // src/learner/storage.ts
 init_constants();
-import fs26 from "fs";
+import fs27 from "fs";
 import path20 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
@@ -6645,8 +6682,8 @@ var DEFAULT_STATE = {
   lastAnalysisTimestamp: null
 };
 function ensureLearningDir() {
-  if (!fs26.existsSync(LEARNING_DIR)) {
-    fs26.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs27.existsSync(LEARNING_DIR)) {
+    fs27.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
@@ -6664,49 +6701,49 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs26.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs27.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs26.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs27.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs26.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs27.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs26.existsSync(filePath)) return [];
-  const lines = fs26.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  if (!fs27.existsSync(filePath)) return [];
+  const lines = fs27.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   return lines.map((line) => JSON.parse(line));
 }
 function getEventCount() {
   const filePath = sessionFilePath();
-  if (!fs26.existsSync(filePath)) return 0;
-  const content = fs26.readFileSync(filePath, "utf-8");
+  if (!fs27.existsSync(filePath)) return 0;
+  const content = fs27.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs26.existsSync(filePath)) fs26.unlinkSync(filePath);
+  if (fs27.existsSync(filePath)) fs27.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs26.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs27.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs26.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs27.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs26.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs27.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
 }
 
 // src/learner/writer.ts
-import fs27 from "fs";
+import fs28 from "fs";
 import path21 from "path";
 var LEARNED_START = "<!-- caliber:learned -->";
 var LEARNED_END = "<!-- /caliber:learned -->";
@@ -6727,8 +6764,8 @@ function writeLearnedContent(update) {
 function writeLearnedSection(content) {
   const claudeMdPath = "CLAUDE.md";
   let existing = "";
-  if (fs27.existsSync(claudeMdPath)) {
-    existing = fs27.readFileSync(claudeMdPath, "utf-8");
+  if (fs28.existsSync(claudeMdPath)) {
+    existing = fs28.readFileSync(claudeMdPath, "utf-8");
   }
   const section = `${LEARNED_START}
 ${content}
@@ -6742,15 +6779,15 @@ ${LEARNED_END}`;
     const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
     updated = existing + separator + "\n" + section + "\n";
   }
-  fs27.writeFileSync(claudeMdPath, updated);
+  fs28.writeFileSync(claudeMdPath, updated);
 }
 function writeLearnedSkill(skill) {
   const skillDir = path21.join(".claude", "skills", skill.name);
-  if (!fs27.existsSync(skillDir)) fs27.mkdirSync(skillDir, { recursive: true });
+  if (!fs28.existsSync(skillDir)) fs28.mkdirSync(skillDir, { recursive: true });
   const skillPath = path21.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs27.existsSync(skillPath)) {
-    const existing = fs27.readFileSync(skillPath, "utf-8");
-    fs27.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  if (!skill.isNew && fs28.existsSync(skillPath)) {
+    const existing = fs28.readFileSync(skillPath, "utf-8");
+    fs28.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -6759,14 +6796,14 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs27.writeFileSync(skillPath, frontmatter + skill.content);
+    fs28.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function readLearnedSection() {
   const claudeMdPath = "CLAUDE.md";
-  if (!fs27.existsSync(claudeMdPath)) return null;
-  const content = fs27.readFileSync(claudeMdPath, "utf-8");
+  if (!fs28.existsSync(claudeMdPath)) return null;
+  const content = fs28.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return null;
@@ -6957,7 +6994,7 @@ Learned items in CLAUDE.md: ${chalk16.cyan(String(lineCount))}`);
 // src/cli.ts
 var __dirname = path22.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs28.readFileSync(path22.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs29.readFileSync(path22.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
@@ -7031,22 +7068,22 @@ learn.command("remove").description("Remove learning hooks from .claude/settings
 learn.command("status").description("Show learning system status").action(tracked("learn:status", learnStatusCommand));
 
 // src/utils/version-check.ts
-import fs29 from "fs";
+import fs30 from "fs";
 import path23 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { execSync as execSync10 } from "child_process";
+import { execSync as execSync11 } from "child_process";
 import chalk17 from "chalk";
 import ora6 from "ora";
 import confirm from "@inquirer/confirm";
 var __dirname_vc = path23.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs29.readFileSync(path23.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs30.readFileSync(path23.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getInstalledVersion() {
   try {
-    const globalRoot = execSync10("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const globalRoot = execSync11("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     const pkgPath = path23.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs29.readFileSync(pkgPath, "utf-8")).version;
+    return JSON.parse(fs30.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -7089,7 +7126,7 @@ Update available: ${current} -> ${latest}`)
     }
     const spinner = ora6("Updating caliber...").start();
     try {
-      execSync10(`npm install -g @rely-ai/caliber@${latest}`, {
+      execSync11(`npm install -g @rely-ai/caliber@${latest}`, {
         stdio: "pipe",
         timeout: 12e4,
         env: { ...process.env, npm_config_fund: "false", npm_config_audit: "false" }
@@ -7106,7 +7143,7 @@ Update available: ${current} -> ${latest}`)
       console.log(chalk17.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
-      execSync10(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
+      execSync11(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
         stdio: "inherit",
         env: { ...process.env, CALIBER_SKIP_UPDATE_CHECK: "1" }
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rely-ai/caliber",
-  "version": "1.7.4",
+  "version": "1.7.5",
   "description": "Analyze your codebase and generate optimized AI agent configs (CLAUDE.md, .cursorrules, skills) — no API key needed",
   "type": "module",
   "bin": {