@rely-ai/caliber 1.0.0 → 1.1.0

package/dist/bin.js

@@ -51,8 +51,8 @@ var init_constants = __esm({
 
 // src/cli.ts
 import { Command } from "commander";
-import fs24 from "fs";
-import path21 from "path";
+import fs25 from "fs";
+import path22 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/onboard.ts
@@ -60,7 +60,7 @@ import chalk4 from "chalk";
 import ora from "ora";
 import readline3 from "readline";
 import select2 from "@inquirer/select";
-import fs17 from "fs";
+import fs18 from "fs";
 
 // src/fingerprint/index.ts
 import fs7 from "fs";
@@ -2127,16 +2127,25 @@ import path12 from "path";
 var STAGED_DIR = path12.join(CALIBER_DIR, "staged");
 var PROPOSED_DIR = path12.join(STAGED_DIR, "proposed");
 var CURRENT_DIR = path12.join(STAGED_DIR, "current");
+function normalizeContent(content) {
+  return content.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
 function stageFiles(files, projectDir) {
   cleanupStaging();
   let newFiles = 0;
   let modifiedFiles = 0;
   const stagedFiles = [];
   for (const file of files) {
+    const originalPath = path12.join(projectDir, file.path);
+    if (fs13.existsSync(originalPath)) {
+      const existing = fs13.readFileSync(originalPath, "utf-8");
+      if (normalizeContent(existing) === normalizeContent(file.content)) {
+        continue;
+      }
+    }
     const proposedPath = path12.join(PROPOSED_DIR, file.path);
     fs13.mkdirSync(path12.dirname(proposedPath), { recursive: true });
     fs13.writeFileSync(proposedPath, file.content);
-    const originalPath = path12.join(projectDir, file.path);
     if (fs13.existsSync(originalPath)) {
       const currentPath = path12.join(CURRENT_DIR, file.path);
       fs13.mkdirSync(path12.dirname(currentPath), { recursive: true });
@@ -2715,15 +2724,15 @@ function computeGrade(score) {
 // src/scoring/checks/coverage.ts
 import { readFileSync, readdirSync } from "fs";
 import { join } from "path";
-function readFileOrNull(path23) {
+function readFileOrNull(path24) {
   try {
-    return readFileSync(path23, "utf-8");
+    return readFileSync(path24, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path23) {
-  const content = readFileOrNull(path23);
+function readJsonOrNull(path24) {
+  const content = readFileOrNull(path24);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -3079,9 +3088,9 @@ function checkExistence(dir) {
 // src/scoring/checks/quality.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { join as join3 } from "path";
-function readFileOrNull2(path23) {
+function readFileOrNull2(path24) {
   try {
-    return readFileSync3(path23, "utf-8");
+    return readFileSync3(path24, "utf-8");
   } catch {
     return null;
   }
@@ -3232,15 +3241,15 @@ function checkQuality(dir) {
 // src/scoring/checks/accuracy.ts
 import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync } from "fs";
 import { join as join4 } from "path";
-function readFileOrNull3(path23) {
+function readFileOrNull3(path24) {
   try {
-    return readFileSync4(path23, "utf-8");
+    return readFileSync4(path24, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull2(path23) {
-  const content = readFileOrNull3(path23);
+function readJsonOrNull2(path24) {
+  const content = readFileOrNull3(path24);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -3423,9 +3432,9 @@ function checkAccuracy(dir) {
 // src/scoring/checks/freshness.ts
 import { readFileSync as readFileSync5, statSync as statSync2 } from "fs";
 import { join as join5 } from "path";
-function readFileOrNull4(path23) {
+function readFileOrNull4(path24) {
   try {
-    return readFileSync5(path23, "utf-8");
+    return readFileSync5(path24, "utf-8");
   } catch {
     return null;
   }
@@ -3535,9 +3544,9 @@ function checkFreshness(dir) {
 import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync4 } from "fs";
 import { execSync as execSync7 } from "child_process";
 import { join as join6 } from "path";
-function readFileOrNull5(path23) {
+function readFileOrNull5(path24) {
   try {
-    return readFileSync6(path23, "utf-8");
+    return readFileSync6(path24, "utf-8");
   } catch {
     return null;
   }
@@ -3630,6 +3639,29 @@ function checkBonus(dir) {
   return checks;
 }
 
+// src/scoring/dismissed.ts
+init_constants();
+import fs17 from "fs";
+import path16 from "path";
+var DISMISSED_FILE = path16.join(CALIBER_DIR, "dismissed-checks.json");
+function readDismissedChecks() {
+  try {
+    if (!fs17.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs17.readFileSync(DISMISSED_FILE, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function writeDismissedChecks(checks) {
+  if (!fs17.existsSync(CALIBER_DIR)) {
+    fs17.mkdirSync(CALIBER_DIR, { recursive: true });
+  }
+  fs17.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+}
+function getDismissedIds() {
+  return new Set(readDismissedChecks().map((c) => c.id));
+}
+
 // src/scoring/index.ts
 function sumCategory(checks, category) {
   const categoryChecks = checks.filter((c) => c.category === category);
@@ -3666,7 +3698,8 @@ function computeLocalScore(dir, targetAgent) {
     ...checkFreshness(dir),
     ...checkBonus(dir)
   ];
-  const checks = filterChecksForTarget(allChecks, target);
+  const dismissed = getDismissedIds();
+  const checks = filterChecksForTarget(allChecks, target).filter((c) => !dismissed.has(c.id));
   const maxPossible = checks.reduce((s, c) => s + c.maxPoints, 0);
   const earned = checks.reduce((s, c) => s + c.earnedPoints, 0);
   const score = maxPossible > 0 ? Math.min(100, Math.max(0, Math.round(earned / maxPossible * 100))) : 0;
@@ -3772,7 +3805,7 @@ function displayScoreSummary(result) {
     const remaining = failing.length - shown.length;
     const moreText = remaining > 0 ? ` (+${remaining} more)` : "";
     console.log(chalk3.dim(`
-  Run ${chalk3.reset("caliber score")} for details.${moreText}`));
+  Run ${chalk3.hex("#83D1EB")("caliber score")} for details.${moreText}`));
   }
   console.log("");
 }
@@ -3874,12 +3907,23 @@ async function initCommand(options) {
   console.log(chalk4.dim(`  Files: ${fingerprint.fileTree.length} found
 `));
   const targetAgent = options.agent || await promptAgent();
+  const preScore = computeLocalScore(process.cwd(), targetAgent);
+  const failingForDismissal = preScore.checks.filter((c) => !c.passed && c.maxPoints > 0);
+  if (failingForDismissal.length > 0) {
+    const newDismissals = await evaluateDismissals(failingForDismissal, fingerprint);
+    if (newDismissals.length > 0) {
+      const existing = readDismissedChecks();
+      const existingIds = new Set(existing.map((d) => d.id));
+      const merged = [...existing, ...newDismissals.filter((d) => !existingIds.has(d.id))];
+      writeDismissedChecks(merged);
+    }
+  }
   const baselineScore = computeLocalScore(process.cwd(), targetAgent);
   displayScoreSummary(baselineScore);
   const hasExistingConfig = !!(fingerprint.existingConfigs.claudeMd || fingerprint.existingConfigs.claudeSettings || fingerprint.existingConfigs.claudeSkills?.length || fingerprint.existingConfigs.cursorrules || fingerprint.existingConfigs.cursorRules?.length);
   if (hasExistingConfig && baselineScore.score === 100) {
     console.log(chalk4.bold.green("  Your setup is already optimal \u2014 nothing to change.\n"));
-    console.log(chalk4.dim("  Run `caliber onboard --force` to regenerate anyway.\n"));
+    console.log(chalk4.dim("  Run ") + chalk4.hex("#83D1EB")("caliber onboard --force") + chalk4.dim(" to regenerate anyway.\n"));
     if (!options.force) return;
   }
   const isEmpty = fingerprint.fileTree.length < 3;
@@ -4042,14 +4086,14 @@ async function initCommand(options) {
     const hookResult = installHook();
     if (hookResult.installed) {
       console.log(`  ${chalk4.green("\u2713")} Claude Code hook installed \u2014 docs update on session end`);
-      console.log(chalk4.dim("    Run `caliber hooks remove` to disable"));
+      console.log(chalk4.dim("    Run ") + chalk4.hex("#83D1EB")("caliber hooks remove") + chalk4.dim(" to disable"));
     } else if (hookResult.alreadyInstalled) {
       console.log(chalk4.dim("  Claude Code hook already installed"));
     }
     const learnResult = installLearningHooks();
     if (learnResult.installed) {
       console.log(`  ${chalk4.green("\u2713")} Learning hooks installed \u2014 session insights captured automatically`);
-      console.log(chalk4.dim("    Run `caliber learn remove` to disable"));
+      console.log(chalk4.dim("    Run ") + chalk4.hex("#83D1EB")("caliber learn remove") + chalk4.dim(" to disable"));
     } else if (learnResult.alreadyInstalled) {
       console.log(chalk4.dim("  Learning hooks already installed"));
     }
@@ -4058,7 +4102,7 @@ async function initCommand(options) {
     const precommitResult = installPreCommitHook();
     if (precommitResult.installed) {
       console.log(`  ${chalk4.green("\u2713")} Pre-commit hook installed \u2014 docs refresh before each commit`);
-      console.log(chalk4.dim("    Run `caliber hooks remove-precommit` to disable"));
+      console.log(chalk4.dim("    Run ") + chalk4.hex("#83D1EB")("caliber hooks remove-precommit") + chalk4.dim(" to disable"));
     } else if (precommitResult.alreadyInstalled) {
       console.log(chalk4.dim("  Pre-commit hook already installed"));
     } else {
@@ -4066,7 +4110,7 @@ async function initCommand(options) {
     }
   }
   if (hookChoice === "skip") {
-    console.log(chalk4.dim("  Skipped auto-refresh hooks. Run `caliber hooks install` later to enable."));
+    console.log(chalk4.dim("  Skipped auto-refresh hooks. Run ") + chalk4.hex("#83D1EB")("caliber hooks install") + chalk4.dim(" later to enable."));
   }
   const afterScore = computeLocalScore(process.cwd(), targetAgent);
   if (afterScore.score < baselineScore.score) {
@@ -4079,12 +4123,12 @@ async function initCommand(options) {
       }
     } catch {
     }
-    console.log(chalk4.dim("  Run `caliber onboard --force` to override.\n"));
+    console.log(chalk4.dim("  Run ") + chalk4.hex("#83D1EB")("caliber onboard --force") + chalk4.dim(" to override.\n"));
     return;
   }
   displayScoreDelta(baselineScore, afterScore);
   console.log(chalk4.bold.green("  Onboarding complete! Your project is ready for AI-assisted development."));
-  console.log(chalk4.dim("  Run `caliber undo` to revert changes.\n"));
+  console.log(chalk4.dim("  Run ") + chalk4.hex("#83D1EB")("caliber undo") + chalk4.dim(" to revert changes.\n"));
   console.log(chalk4.bold("  Next steps:\n"));
   console.log(`    ${title("caliber score")}        See your full config breakdown`);
   console.log(`    ${title("caliber recommend")}    Discover community skills for your stack`);
@@ -4134,7 +4178,7 @@ async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
 }
 function summarizeSetup(action, setup) {
   const descriptions = setup.fileDescriptions;
-  const files = descriptions ? Object.entries(descriptions).map(([path23, desc]) => `  ${path23}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
+  const files = descriptions ? Object.entries(descriptions).map(([path24, desc]) => `  ${path24}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
   return `${action}. Files:
 ${files}`;
 }
@@ -4155,6 +4199,36 @@ Return {"valid": true} or {"valid": false}. Nothing else.`,
     return true;
   }
 }
+async function evaluateDismissals(failingChecks, fingerprint) {
+  const fastModel = process.env.ANTHROPIC_SMALL_FAST_MODEL;
+  const checkList = failingChecks.map((c) => ({
+    id: c.id,
+    name: c.name,
+    suggestion: c.suggestion
+  }));
+  try {
+    const result = await llmJsonCall({
+      system: `You evaluate whether scoring checks are applicable to a project.
+Given the project's languages/frameworks and a list of failing checks, return which checks are NOT applicable.
+
+Only dismiss checks that truly don't apply \u2014 e.g. "Build/test/lint commands" for a pure Terraform/HCL repo with no build system.
+Do NOT dismiss checks that could reasonably apply even if the project doesn't use them yet.
+
+Return {"dismissed": [{"id": "check_id", "reason": "brief reason"}]} or {"dismissed": []} if all apply.`,
+      prompt: `Languages: ${fingerprint.languages.join(", ") || "none"}
+Frameworks: ${fingerprint.frameworks.join(", ") || "none"}
+
+Failing checks:
+${JSON.stringify(checkList, null, 2)}`,
+      maxTokens: 200,
+      ...fastModel ? { model: fastModel } : {}
+    });
+    if (!Array.isArray(result.dismissed)) return [];
+    return result.dismissed.filter((d) => d.id && d.reason && failingChecks.some((c) => c.id === d.id)).map((d) => ({ id: d.id, reason: d.reason, dismissedAt: (/* @__PURE__ */ new Date()).toISOString() }));
+  } catch {
+    return [];
+  }
+}
 function promptInput2(question) {
   const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve2) => {
@@ -4224,8 +4298,8 @@ async function openReview(method, stagedFiles) {
     return;
   }
   const fileInfos = stagedFiles.map((file) => {
-    const proposed = fs17.readFileSync(file.proposedPath, "utf-8");
-    const current = file.currentPath ? fs17.readFileSync(file.currentPath, "utf-8") : "";
+    const proposed = fs18.readFileSync(file.proposedPath, "utf-8");
+    const current = file.currentPath ? fs18.readFileSync(file.currentPath, "utf-8") : "";
     const patch = createTwoFilesPatch(
       file.isNew ? "/dev/null" : file.relativePath,
       file.relativePath,
@@ -4408,7 +4482,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs17.existsSync("CLAUDE.md") ? chalk4.yellow("~") : chalk4.green("+");
+      const icon = fs18.existsSync("CLAUDE.md") ? chalk4.yellow("~") : chalk4.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk4.bold("CLAUDE.md")}`);
       if (desc) console.log(chalk4.dim(`    ${desc}`));
@@ -4418,7 +4492,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 = fs17.existsSync(skillPath) ? chalk4.yellow("~") : chalk4.green("+");
+        const icon = fs18.existsSync(skillPath) ? chalk4.yellow("~") : chalk4.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk4.bold(skillPath)}`);
         console.log(chalk4.dim(`    ${desc || skill.description || skill.name}`));
@@ -4428,7 +4502,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs17.existsSync(".cursorrules") ? chalk4.yellow("~") : chalk4.green("+");
+      const icon = fs18.existsSync(".cursorrules") ? chalk4.yellow("~") : chalk4.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk4.bold(".cursorrules")}`);
       if (desc) console.log(chalk4.dim(`    ${desc}`));
@@ -4438,7 +4512,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 = fs17.existsSync(skillPath) ? chalk4.yellow("~") : chalk4.green("+");
+        const icon = fs18.existsSync(skillPath) ? chalk4.yellow("~") : chalk4.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk4.bold(skillPath)}`);
         console.log(chalk4.dim(`    ${desc || skill.description || skill.name}`));
@@ -4449,7 +4523,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rules) && rules.length > 0) {
       for (const rule of rules) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs17.existsSync(rulePath) ? chalk4.yellow("~") : chalk4.green("+");
+        const icon = fs18.existsSync(rulePath) ? chalk4.yellow("~") : chalk4.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk4.bold(rulePath)}`);
         if (desc) {
@@ -4462,7 +4536,7 @@ function printSetupSummary(setup) {
       }
     }
   }
-  if (!fs17.existsSync("AGENTS.md")) {
+  if (!fs18.existsSync("AGENTS.md")) {
     console.log(`  ${chalk4.green("+")} ${chalk4.bold("AGENTS.md")}`);
     console.log(chalk4.dim("    Cross-agent coordination file"));
     console.log("");
@@ -4490,8 +4564,8 @@ function ensurePermissions() {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs17.existsSync(settingsPath)) {
-      settings = JSON.parse(fs17.readFileSync(settingsPath, "utf-8"));
+    if (fs18.existsSync(settingsPath)) {
+      settings = JSON.parse(fs18.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -4505,8 +4579,8 @@ function ensurePermissions() {
     "Bash(git *)"
   ];
   settings.permissions = permissions;
-  if (!fs17.existsSync(".claude")) fs17.mkdirSync(".claude", { recursive: true });
-  fs17.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs18.existsSync(".claude")) fs18.mkdirSync(".claude", { recursive: true });
+  fs18.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function collectSetupFiles(setup) {
   const files = [];
@@ -4536,7 +4610,7 @@ function collectSetupFiles(setup) {
       }
     }
   }
-  if (!fs17.existsSync("AGENTS.md")) {
+  if (!fs18.existsSync("AGENTS.md")) {
     const agentRefs = [];
     if (claude) agentRefs.push("See `CLAUDE.md` for Claude Code configuration.");
     if (cursor) agentRefs.push("See `.cursor/rules/` for Cursor rules.");
@@ -4587,7 +4661,7 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk6 from "chalk";
-import fs18 from "fs";
+import fs19 from "fs";
 async function statusCommand(options) {
   const config = loadConfig();
   const manifest = readManifest();
@@ -4604,16 +4678,16 @@ async function statusCommand(options) {
   if (config) {
     console.log(`  LLM: ${chalk6.green(config.provider)} (${config.model})`);
   } else {
-    console.log(`  LLM: ${chalk6.yellow("Not configured")} \u2014 run \`caliber config\``);
+    console.log(`  LLM: ${chalk6.yellow("Not configured")} \u2014 run ${chalk6.hex("#83D1EB")("caliber config")}`);
   }
   if (!manifest) {
     console.log(`  Setup: ${chalk6.dim("No setup applied")}`);
-    console.log(chalk6.dim("\n  Run `caliber onboard` to get started.\n"));
+    console.log(chalk6.dim("\n  Run ") + chalk6.hex("#83D1EB")("caliber onboard") + chalk6.dim(" to get started.\n"));
     return;
   }
   console.log(`  Files managed: ${chalk6.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs18.existsSync(entry.path);
+    const exists = fs19.existsSync(entry.path);
     const icon = exists ? chalk6.green("\u2713") : chalk6.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -4627,12 +4701,12 @@ import confirm from "@inquirer/confirm";
 async function regenerateCommand(options) {
   const config = loadConfig();
   if (!config) {
-    console.log(chalk7.red("No LLM provider configured. Run `caliber config` (e.g. choose Cursor) or set ANTHROPIC_API_KEY."));
+    console.log(chalk7.red("No LLM provider configured. Run ") + chalk7.hex("#83D1EB")("caliber config") + chalk7.red(" (e.g. choose Cursor) or set ANTHROPIC_API_KEY."));
     throw new Error("__exit__");
   }
   const manifest = readManifest();
   if (!manifest) {
-    console.log(chalk7.yellow("No existing setup found. Run `caliber onboard` first."));
+    console.log(chalk7.yellow("No existing setup found. Run ") + chalk7.hex("#83D1EB")("caliber onboard") + chalk7.yellow(" first."));
     throw new Error("__exit__");
   }
   const spinner = ora3("Re-analyzing project...").start();
@@ -4700,13 +4774,13 @@ import { mkdirSync, readFileSync as readFileSync7, readdirSync as readdirSync5,
 import { join as join8, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
-import fs19 from "fs";
-import path16 from "path";
+import fs20 from "fs";
+import path17 from "path";
 import crypto2 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path16.join(dir, "CLAUDE.md");
-  if (fs19.existsSync(claudeMdPath)) {
+  const claudeMdPath = path17.join(dir, "CLAUDE.md");
+  if (fs20.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -4715,10 +4789,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path16.join(dir, ".claude", "skills");
-  if (fs19.existsSync(skillsDir)) {
-    for (const file of fs19.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path16.join(skillsDir, file);
+  const skillsDir = path17.join(dir, ".claude", "skills");
+  if (fs20.existsSync(skillsDir)) {
+    for (const file of fs20.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path17.join(skillsDir, file);
       items.push({
         type: "skill",
         platform: "claude",
@@ -4728,10 +4802,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path16.join(dir, ".mcp.json");
-  if (fs19.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path17.join(dir, ".mcp.json");
+  if (fs20.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs19.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs20.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -4746,8 +4820,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path16.join(dir, ".cursorrules");
-  if (fs19.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path17.join(dir, ".cursorrules");
+  if (fs20.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -4756,10 +4830,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path16.join(dir, ".cursor", "rules");
-  if (fs19.existsSync(cursorRulesDir)) {
-    for (const file of fs19.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path16.join(cursorRulesDir, file);
+  const cursorRulesDir = path17.join(dir, ".cursor", "rules");
+  if (fs20.existsSync(cursorRulesDir)) {
+    for (const file of fs20.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path17.join(cursorRulesDir, file);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -4769,12 +4843,12 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path16.join(dir, ".cursor", "skills");
-  if (fs19.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path17.join(dir, ".cursor", "skills");
+  if (fs20.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs19.readdirSync(cursorSkillsDir)) {
-        const skillFile = path16.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs19.existsSync(skillFile)) {
+      for (const name of fs20.readdirSync(cursorSkillsDir)) {
+        const skillFile = path17.join(cursorSkillsDir, name, "SKILL.md");
+        if (fs20.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -4787,10 +4861,10 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorMcpPath = path16.join(dir, ".cursor", "mcp.json");
-  if (fs19.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path17.join(dir, ".cursor", "mcp.json");
+  if (fs20.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs19.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs20.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -4808,7 +4882,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs19.readFileSync(filePath, "utf-8");
+  const text = fs20.readFileSync(filePath, "utf-8");
   return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -5374,18 +5448,18 @@ async function scoreCommand(options) {
   const separator = chalk9.gray("  " + "\u2500".repeat(53));
   console.log(separator);
   if (result.score < 40) {
-    console.log(chalk9.gray("  Run ") + chalk9.hex("#f97316")("caliber onboard") + chalk9.gray(" to generate a complete, optimized setup."));
+    console.log(chalk9.gray("  Run ") + chalk9.hex("#83D1EB")("caliber onboard") + chalk9.gray(" to generate a complete, optimized setup."));
   } else if (result.score < 70) {
-    console.log(chalk9.gray("  Run ") + chalk9.hex("#f97316")("caliber onboard") + chalk9.gray(" to improve your setup."));
+    console.log(chalk9.gray("  Run ") + chalk9.hex("#83D1EB")("caliber onboard") + chalk9.gray(" to improve your setup."));
   } else {
-    console.log(chalk9.green("  Looking good!") + chalk9.gray(" Run ") + chalk9.hex("#f97316")("caliber update") + chalk9.gray(" to keep it fresh."));
+    console.log(chalk9.green("  Looking good!") + chalk9.gray(" Run ") + chalk9.hex("#83D1EB")("caliber update") + chalk9.gray(" to keep it fresh."));
   }
   console.log("");
 }
 
 // src/commands/refresh.ts
-import fs21 from "fs";
-import path18 from "path";
+import fs22 from "fs";
+import path19 from "path";
 import chalk10 from "chalk";
 import ora5 from "ora";
 
@@ -5462,37 +5536,37 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs20 from "fs";
-import path17 from "path";
+import fs21 from "fs";
+import path18 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs20.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs21.writeFileSync("CLAUDE.md", docs.claudeMd);
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs20.writeFileSync("README.md", docs.readmeMd);
+    fs21.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs20.writeFileSync(".cursorrules", docs.cursorrules);
+    fs21.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path17.join(".cursor", "rules");
-    if (!fs20.existsSync(rulesDir)) fs20.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path18.join(".cursor", "rules");
+    if (!fs21.existsSync(rulesDir)) fs21.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      const filePath = path17.join(rulesDir, rule.filename);
-      fs20.writeFileSync(filePath, rule.content);
+      const filePath = path18.join(rulesDir, rule.filename);
+      fs21.writeFileSync(filePath, rule.content);
       written.push(filePath);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path17.join(".claude", "skills");
-    if (!fs20.existsSync(skillsDir)) fs20.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path18.join(".claude", "skills");
+    if (!fs21.existsSync(skillsDir)) fs21.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      const filePath = path17.join(skillsDir, skill.filename);
-      fs20.writeFileSync(filePath, skill.content);
+      const filePath = path18.join(skillsDir, skill.filename);
+      fs21.writeFileSync(filePath, skill.content);
       written.push(filePath);
     }
   }
@@ -5567,11 +5641,11 @@ function log(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs21.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs22.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path18.join(parentDir, entry.name);
-      if (fs21.existsSync(path18.join(childPath, ".git"))) {
+      const childPath = path19.join(parentDir, entry.name);
+      if (fs22.existsSync(path19.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -5649,7 +5723,7 @@ async function refreshCommand(options) {
     const config = loadConfig();
     if (!config) {
       if (quiet) return;
-      console.log(chalk10.red("No LLM provider configured. Run `caliber config` (e.g. choose Cursor) or set an API key."));
+      console.log(chalk10.red("No LLM provider configured. Run ") + chalk10.hex("#83D1EB")("caliber config") + chalk10.red(" (e.g. choose Cursor) or set an API key."));
       throw new Error("__exit__");
     }
     if (isGitRepo()) {
@@ -5666,7 +5740,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path18.basename(repo);
+      const repoName = path19.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -5913,8 +5987,8 @@ function readStdin() {
 
 // src/learner/storage.ts
 init_constants();
-import fs22 from "fs";
-import path19 from "path";
+import fs23 from "fs";
+import path20 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -5922,15 +5996,15 @@ var DEFAULT_STATE = {
   lastAnalysisTimestamp: null
 };
 function ensureLearningDir() {
-  if (!fs22.existsSync(LEARNING_DIR)) {
-    fs22.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs23.existsSync(LEARNING_DIR)) {
+    fs23.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
-  return path19.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path20.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path19.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path20.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -5941,50 +6015,50 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs22.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs23.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs22.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs23.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs22.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs23.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs22.existsSync(filePath)) return [];
-  const lines = fs22.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  if (!fs23.existsSync(filePath)) return [];
+  const lines = fs23.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   return lines.map((line) => JSON.parse(line));
 }
 function getEventCount() {
   const filePath = sessionFilePath();
-  if (!fs22.existsSync(filePath)) return 0;
-  const content = fs22.readFileSync(filePath, "utf-8");
+  if (!fs23.existsSync(filePath)) return 0;
+  const content = fs23.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs22.existsSync(filePath)) fs22.unlinkSync(filePath);
+  if (fs23.existsSync(filePath)) fs23.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs22.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs23.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs22.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs23.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs22.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs23.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
 }
 
 // src/learner/writer.ts
-import fs23 from "fs";
-import path20 from "path";
+import fs24 from "fs";
+import path21 from "path";
 var LEARNED_START = "<!-- caliber:learned -->";
 var LEARNED_END = "<!-- /caliber:learned -->";
 function writeLearnedContent(update) {
@@ -6004,8 +6078,8 @@ function writeLearnedContent(update) {
 function writeLearnedSection(content) {
   const claudeMdPath = "CLAUDE.md";
   let existing = "";
-  if (fs23.existsSync(claudeMdPath)) {
-    existing = fs23.readFileSync(claudeMdPath, "utf-8");
+  if (fs24.existsSync(claudeMdPath)) {
+    existing = fs24.readFileSync(claudeMdPath, "utf-8");
   }
   const section = `${LEARNED_START}
 ${content}
@@ -6019,15 +6093,15 @@ ${LEARNED_END}`;
     const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
     updated = existing + separator + "\n" + section + "\n";
   }
-  fs23.writeFileSync(claudeMdPath, updated);
+  fs24.writeFileSync(claudeMdPath, updated);
 }
 function writeLearnedSkill(skill) {
-  const skillDir = path20.join(".claude", "skills", skill.name);
-  if (!fs23.existsSync(skillDir)) fs23.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path20.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs23.existsSync(skillPath)) {
-    const existing = fs23.readFileSync(skillPath, "utf-8");
-    fs23.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  const skillDir = path21.join(".claude", "skills", skill.name);
+  if (!fs24.existsSync(skillDir)) fs24.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path21.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs24.existsSync(skillPath)) {
+    const existing = fs24.readFileSync(skillPath, "utf-8");
+    fs24.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -6036,14 +6110,14 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs23.writeFileSync(skillPath, frontmatter + skill.content);
+    fs24.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function readLearnedSection() {
   const claudeMdPath = "CLAUDE.md";
-  if (!fs23.existsSync(claudeMdPath)) return null;
-  const content = fs23.readFileSync(claudeMdPath, "utf-8");
+  if (!fs24.existsSync(claudeMdPath)) return null;
+  const content = fs24.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return null;
@@ -6227,9 +6301,9 @@ Learned items in CLAUDE.md: ${chalk13.cyan(String(lineCount))}`);
 }
 
 // src/cli.ts
-var __dirname = path21.dirname(fileURLToPath(import.meta.url));
+var __dirname = path22.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs24.readFileSync(path21.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs25.readFileSync(path22.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
@@ -6251,22 +6325,22 @@ learn.command("remove").description("Remove learning hooks from .claude/settings
 learn.command("status").description("Show learning system status").action(learnStatusCommand);
 
 // src/utils/version-check.ts
-import fs25 from "fs";
-import path22 from "path";
+import fs26 from "fs";
+import path23 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync as execSync9 } from "child_process";
 import chalk14 from "chalk";
 import ora6 from "ora";
 import confirm2 from "@inquirer/confirm";
-var __dirname_vc = path22.dirname(fileURLToPath2(import.meta.url));
+var __dirname_vc = path23.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs25.readFileSync(path22.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs26.readFileSync(path23.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getInstalledVersion() {
   try {
     const globalRoot = execSync9("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const pkgPath = path22.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs25.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = path23.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    return JSON.parse(fs26.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }

package/package.json

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