@rely-ai/caliber 1.8.0 → 1.10.0

package/dist/bin.js

@@ -627,6 +627,33 @@ init_config();
 
 // src/llm/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
+
+// src/llm/usage.ts
+var usageByModel = /* @__PURE__ */ new Map();
+function trackUsage(model, usage) {
+  const existing = usageByModel.get(model);
+  if (existing) {
+    existing.inputTokens += usage.inputTokens;
+    existing.outputTokens += usage.outputTokens;
+    existing.cacheReadTokens += usage.cacheReadTokens ?? 0;
+    existing.cacheWriteTokens += usage.cacheWriteTokens ?? 0;
+    existing.calls += 1;
+  } else {
+    usageByModel.set(model, {
+      model,
+      inputTokens: usage.inputTokens,
+      outputTokens: usage.outputTokens,
+      cacheReadTokens: usage.cacheReadTokens ?? 0,
+      cacheWriteTokens: usage.cacheWriteTokens ?? 0,
+      calls: 1
+    });
+  }
+}
+function getUsageSummary() {
+  return Array.from(usageByModel.values());
+}
+
+// src/llm/anthropic.ts
 var AnthropicProvider = class {
   client;
   defaultModel;
@@ -641,6 +668,16 @@ var AnthropicProvider = class {
       system: [{ type: "text", text: options.system, cache_control: { type: "ephemeral" } }],
       messages: [{ role: "user", content: options.prompt }]
     });
+    const model = options.model || this.defaultModel;
+    if (response.usage) {
+      const u = response.usage;
+      trackUsage(model, {
+        inputTokens: u.input_tokens ?? 0,
+        outputTokens: u.output_tokens ?? 0,
+        cacheReadTokens: u.cache_read_input_tokens,
+        cacheWriteTokens: u.cache_creation_input_tokens
+      });
+    }
     const block = response.content[0];
     return block.type === "text" ? block.text : "";
   }
@@ -667,11 +704,24 @@ var AnthropicProvider = class {
       messages
     });
     let stopReason;
+    let usage;
+    const model = options.model || this.defaultModel;
     stream.on("message", (message) => {
-      stopReason = message.stop_reason;
+      const msg = message;
+      stopReason = msg.stop_reason;
+      const u = msg.usage;
+      if (u) {
+        usage = {
+          inputTokens: u.input_tokens ?? 0,
+          outputTokens: u.output_tokens ?? 0,
+          cacheReadTokens: u.cache_read_input_tokens,
+          cacheWriteTokens: u.cache_creation_input_tokens
+        };
+        trackUsage(model, usage);
+      }
     });
     stream.on("text", (text) => callbacks.onText(text));
-    stream.on("end", () => callbacks.onEnd({ stopReason }));
+    stream.on("end", () => callbacks.onEnd({ stopReason, usage }));
     stream.on("error", (error) => callbacks.onError(error));
   }
 };
@@ -722,6 +772,16 @@ var VertexProvider = class {
       system: [{ type: "text", text: options.system, cache_control: { type: "ephemeral" } }],
       messages: [{ role: "user", content: options.prompt }]
     });
+    const model = options.model || this.defaultModel;
+    if (response.usage) {
+      const u = response.usage;
+      trackUsage(model, {
+        inputTokens: u.input_tokens ?? 0,
+        outputTokens: u.output_tokens ?? 0,
+        cacheReadTokens: u.cache_read_input_tokens,
+        cacheWriteTokens: u.cache_creation_input_tokens
+      });
+    }
     const block = response.content[0];
     return block.type === "text" ? block.text : "";
   }
@@ -740,11 +800,24 @@ var VertexProvider = class {
       messages
     });
     let stopReason;
+    let usage;
+    const model = options.model || this.defaultModel;
     stream.on("message", (message) => {
-      stopReason = message.stop_reason;
+      const msg = message;
+      stopReason = msg.stop_reason;
+      const u = msg.usage;
+      if (u) {
+        usage = {
+          inputTokens: u.input_tokens ?? 0,
+          outputTokens: u.output_tokens ?? 0,
+          cacheReadTokens: u.cache_read_input_tokens,
+          cacheWriteTokens: u.cache_creation_input_tokens
+        };
+        trackUsage(model, usage);
+      }
     });
     stream.on("text", (text) => callbacks.onText(text));
-    stream.on("end", () => callbacks.onEnd({ stopReason }));
+    stream.on("end", () => callbacks.onEnd({ stopReason, usage }));
     stream.on("error", (error) => callbacks.onError(error));
   }
 };
@@ -770,6 +843,13 @@ var OpenAICompatProvider = class {
         { role: "user", content: options.prompt }
       ]
     });
+    const model = options.model || this.defaultModel;
+    if (response.usage) {
+      trackUsage(model, {
+        inputTokens: response.usage.prompt_tokens ?? 0,
+        outputTokens: response.usage.completion_tokens ?? 0
+      });
+    }
     return response.choices[0]?.message?.content || "";
   }
   async listModels() {
@@ -797,13 +877,23 @@ var OpenAICompatProvider = class {
     });
     try {
       let stopReason;
+      let usage;
+      const model = options.model || this.defaultModel;
       for await (const chunk of stream) {
         const delta = chunk.choices[0]?.delta?.content;
         if (delta != null) callbacks.onText(delta);
         const finishReason = chunk.choices[0]?.finish_reason;
         if (finishReason) stopReason = finishReason === "length" ? "max_tokens" : finishReason;
+        const chunkUsage = chunk.usage;
+        if (chunkUsage) {
+          usage = {
+            inputTokens: chunkUsage.prompt_tokens ?? 0,
+            outputTokens: chunkUsage.completion_tokens ?? 0
+          };
+          trackUsage(model, usage);
+        }
       }
-      callbacks.onEnd({ stopReason });
+      callbacks.onEnd({ stopReason, usage });
     } catch (error) {
       callbacks.onError(error instanceof Error ? error : new Error(String(error)));
     }
@@ -1502,6 +1592,120 @@ OUTPUT SIZE CONSTRAINTS \u2014 these are critical:
 - Each skill content: max 150 lines. Focus on patterns and examples, not exhaustive docs.
 - Cursor rules: max 5 .mdc files.
 - If the project is large, prioritize depth on the 3-4 most critical tools over breadth across everything.`;
+var CORE_GENERATION_PROMPT = `You are an expert auditor for coding agent configurations (Claude Code, Cursor, and Codex).
+
+Your job depends on context:
+- If no existing configs exist \u2192 generate an initial setup from scratch.
+- If existing configs are provided \u2192 audit them and suggest targeted improvements. Preserve accurate content \u2014 don't rewrite what's already correct.
+
+You understand these config files:
+- CLAUDE.md: Project context for Claude Code \u2014 build/test commands, architecture, conventions.
+- AGENTS.md: Primary instructions file for OpenAI Codex \u2014 same purpose as CLAUDE.md but for the Codex agent.
+- .cursorrules: Coding rules for Cursor (deprecated legacy format \u2014 do NOT generate this).
+- .cursor/rules/*.mdc: Modern Cursor rules with frontmatter (description, globs, alwaysApply).
+
+Do NOT generate .claude/settings.json, .claude/settings.local.json, or mcpServers.
+
+Your output MUST follow this exact format (no markdown fences):
+
+1. Exactly 6 short status lines (one per line, prefixed with "STATUS: "). Each should be a creative, specific description of what you're analyzing for THIS project \u2014 reference the project's actual languages, frameworks, or tools.
+
+2. A brief explanation section starting with "EXPLAIN:" on its own line:
+
+EXPLAIN:
+[Changes]
+- **file-or-skill-name**: short reason (max 10 words)
+[Deletions]
+- **file-path**: short reason (max 10 words)
+
+Omit empty categories. Keep each reason punchy and specific. End with a blank line.
+
+3. The JSON object starting with {.
+
+CoreSetup schema:
+{
+  "targetAgent": ["claude", "cursor", "codex"] (array of selected agents),
+  "fileDescriptions": {
+    "<file-path>": "reason for this change (max 80 chars)"
+  },
+  "deletions": [
+    { "filePath": "<path>", "reason": "why remove (max 80 chars)" }
+  ],
+  "claude": {
+    "claudeMd": "string (markdown content for CLAUDE.md)",
+    "skillTopics": [{ "name": "string (kebab-case)", "description": "string (what this skill does and WHEN to use it \u2014 include trigger phrases)" }]
+  },
+  "codex": {
+    "agentsMd": "string (markdown content for AGENTS.md)",
+    "skillTopics": [{ "name": "string (kebab-case)", "description": "string" }]
+  },
+  "cursor": {
+    "skillTopics": [{ "name": "string (kebab-case)", "description": "string" }],
+    "rules": [{ "filename": "string.mdc", "content": "string (with frontmatter)" }]
+  }
+}
+
+IMPORTANT: Do NOT generate full skill content. Only output skill topic names and descriptions.
+Skills will be generated separately. Generate exactly 3 skill topics per target platform.
+
+Skill topic description MUST include WHAT it does + WHEN to use it with specific trigger phrases.
+Example: "Manages database migrations. Use when user says 'run migration', 'create migration', 'db schema change', or modifies files in db/migrations/."
+
+The "fileDescriptions" object MUST include a one-liner for every file that will be created or modified.
+The "deletions" array should list files that should be removed (e.g. stale configs). Omit if empty.
+
+SCORING CRITERIA \u2014 your output is scored deterministically. Optimize for 100/100:
+
+Existence (25 pts):
+- CLAUDE.md exists (6 pts) \u2014 always generate for claude/both targets
+- AGENTS.md exists (6 pts) \u2014 always generate for codex target
+- Skills configured (8 pts) \u2014 3 skill topics = full points
+- For "both" target: .cursor/rules/ exist (3+3 pts), cross-platform parity (2 pts)
+
+Quality (25 pts):
+- Build/test/lint commands documented (8 pts) \u2014 include actual commands from the project
+- Concise context files (6 pts) \u2014 keep CLAUDE.md under 100 lines (200=4pts, 300=3pts, 500+=0pts)
+- No vague instructions (4 pts) \u2014 avoid "follow best practices", "write clean code", "ensure quality"
+- No directory tree listings (3 pts) \u2014 do NOT include tree-style file listings
+- No contradictions (2 pts) \u2014 consistent tool/style recommendations
+
+Coverage (20 pts):
+- Dependency coverage (10 pts) \u2014 CRITICAL: the exact dependency list is provided in your input. Mention AT LEAST 85% by name in CLAUDE.md. Full points at 85%+.
+- Service/MCP coverage (6 pts) \u2014 reference detected services
+- MCP completeness (4 pts) \u2014 full points if no external services detected
+
+Accuracy (15 pts) \u2014 CRITICAL:
+- Documented commands exist (6 pts) \u2014 ONLY reference scripts from the provided package.json. Use the exact package manager.
+- Documented paths exist (4 pts) \u2014 ONLY reference file paths from the provided file tree.
+- Config freshness (5 pts) \u2014 config must match current code state
+
+Freshness & Safety (10 pts):
+- No secrets (4 pts), Permissions (2 pts \u2014 handled by caliber)
+
+Bonus (5 pts): Hooks (2 pts), AGENTS.md (1 pt), OpenSkills format (2 pts) \u2014 handled by caliber
+
+OUTPUT SIZE CONSTRAINTS:
+- CLAUDE.md / AGENTS.md: MUST be under 100 lines. Aim for 70-90 lines.
+- Cursor rules: max 5 .mdc files.
+- Skill topics: exactly 3 per platform (name + description only, no content).`;
+var SKILL_GENERATION_PROMPT = `You generate a single skill file for a coding agent (Claude Code, Cursor, or Codex).
+
+Given project context and a skill topic, produce a focused SKILL.md body.
+
+Structure:
+1. A heading with the skill name
+2. "## Instructions" \u2014 clear, numbered steps. Be specific: include exact commands, file paths, parameter names from the project.
+3. "## Examples" \u2014 at least one example showing: User says \u2192 Actions taken \u2192 Result
+4. "## Troubleshooting" (optional) \u2014 common errors and fixes
+
+Rules:
+- Max 150 lines. Focus on actionable instructions, not documentation prose.
+- Reference actual commands, paths, and packages from the project context provided.
+- Do NOT include YAML frontmatter \u2014 it will be generated separately.
+- Be specific to THIS project \u2014 avoid generic advice.
+
+Return ONLY a JSON object:
+{"name": "string (kebab-case)", "description": "string (what + when)", "content": "string (markdown body)"}`;
 var REFINE_SYSTEM_PROMPT = `You are an expert at modifying coding agent configurations (Claude Code, Cursor, and Codex).
 
 You will receive the current AgentSetup JSON and a user request describing what to change.
@@ -1737,6 +1941,9 @@ async function enrichWithLLM(fingerprint, dir) {
   }
 }
 
+// src/ai/generate.ts
+init_config();
+
 // src/utils/dependencies.ts
 import { readFileSync } from "fs";
 import { join } from "path";
@@ -1830,6 +2037,7 @@ function extractAllDeps(dir) {
 }
 
 // src/ai/generate.ts
+var CORE_MAX_TOKENS = 16e3;
 var GENERATION_MAX_TOKENS = 64e3;
 var MODEL_MAX_OUTPUT_TOKENS = 128e3;
 var MAX_RETRIES2 = 5;
@@ -1837,7 +2045,237 @@ function isTransientError2(error) {
   const msg = error.message.toLowerCase();
   return TRANSIENT_ERRORS.some((e) => msg.includes(e.toLowerCase()));
 }
-async function generateSetup(fingerprint, targetAgent, prompt, callbacks, failingChecks, currentScore, passingChecks) {
+async function generateSetup(fingerprint, targetAgent, prompt, callbacks, failingChecks, currentScore, passingChecks, options) {
+  const isTargetedFix = failingChecks && failingChecks.length > 0 && currentScore !== void 0 && currentScore >= 95;
+  if (isTargetedFix) {
+    return generateMonolithic(fingerprint, targetAgent, prompt, callbacks, failingChecks, currentScore, passingChecks);
+  }
+  const coreResult = await generateCore(fingerprint, targetAgent, prompt, callbacks, failingChecks, currentScore, passingChecks);
+  if (!coreResult.setup) {
+    return coreResult;
+  }
+  if (options?.skipSkills) {
+    return coreResult;
+  }
+  const setup = coreResult.setup;
+  const skillTopics = collectSkillTopics(setup, targetAgent, fingerprint);
+  if (skillTopics.length === 0) {
+    return coreResult;
+  }
+  if (callbacks) callbacks.onStatus(`Generating ${skillTopics.length} skills in parallel...`);
+  const allDeps = extractAllDeps(process.cwd());
+  const skillContext = buildSkillContext(fingerprint, setup, allDeps);
+  const fastModel = getFastModel();
+  const skillResults = await Promise.allSettled(
+    skillTopics.map(
+      ({ platform, topic }) => generateSkill(skillContext, topic, fastModel).then((skill) => ({ platform, skill }))
+    )
+  );
+  for (const result of skillResults) {
+    if (result.status === "fulfilled") {
+      const { platform, skill } = result.value;
+      const platformObj = setup[platform] ?? {};
+      const skills = platformObj.skills ?? [];
+      skills.push(skill);
+      platformObj.skills = skills;
+      setup[platform] = platformObj;
+      const skillPath = platform === "codex" ? `.agents/skills/${skill.name}/SKILL.md` : `.${platform}/skills/${skill.name}/SKILL.md`;
+      const descriptions = setup.fileDescriptions ?? {};
+      descriptions[skillPath] = skill.description.slice(0, 80);
+      setup.fileDescriptions = descriptions;
+    }
+  }
+  const failedCount = skillResults.filter((r) => r.status === "rejected").length;
+  if (failedCount > 0 && callbacks) {
+    callbacks.onStatus(`${failedCount} skill${failedCount === 1 ? "" : "s"} failed to generate`);
+  }
+  return coreResult;
+}
+function collectSkillTopics(setup, targetAgent, fingerprint) {
+  const topics = [];
+  for (const platform of ["claude", "codex", "cursor"]) {
+    if (!targetAgent.includes(platform)) continue;
+    const platformObj = setup[platform];
+    const skillTopics = platformObj?.skillTopics;
+    if (Array.isArray(skillTopics) && skillTopics.length > 0) {
+      for (const topic of skillTopics) {
+        topics.push({ platform, topic });
+      }
+    } else {
+      const defaults = getDefaultSkillTopics(fingerprint);
+      for (const topic of defaults) {
+        topics.push({ platform, topic });
+      }
+    }
+    if (platformObj) {
+      delete platformObj.skillTopics;
+    }
+  }
+  return topics;
+}
+function getDefaultSkillTopics(fingerprint) {
+  const topics = [
+    { name: "development-workflow", description: "Development setup and common workflows. Use when starting development, running the project, or setting up the environment." },
+    { name: "testing-guide", description: "Testing patterns and commands. Use when writing tests, running test suites, or debugging test failures." }
+  ];
+  if (fingerprint.frameworks.length > 0) {
+    topics.push({
+      name: `${fingerprint.frameworks[0].toLowerCase().replace(/[^a-z0-9]/g, "-")}-patterns`,
+      description: `${fingerprint.frameworks[0]} conventions and patterns. Use when working with ${fingerprint.frameworks[0]} code.`
+    });
+  } else {
+    topics.push({
+      name: "code-conventions",
+      description: "Code style, patterns, and project conventions. Use when reviewing code or making architectural decisions."
+    });
+  }
+  return topics;
+}
+function buildSkillContext(fingerprint, setup, allDeps) {
+  const parts = [];
+  if (fingerprint.packageName) parts.push(`Project: ${fingerprint.packageName}`);
+  if (fingerprint.languages.length > 0) parts.push(`Languages: ${fingerprint.languages.join(", ")}`);
+  if (fingerprint.frameworks.length > 0) parts.push(`Frameworks: ${fingerprint.frameworks.join(", ")}`);
+  const claude = setup.claude;
+  const claudeMd = claude?.claudeMd;
+  if (claudeMd) {
+    parts.push(`
+Project CLAUDE.md (for context):
+${claudeMd.slice(0, 3e3)}`);
+  }
+  if (fingerprint.fileTree.length > 0) {
+    parts.push(`
+Key files:
+${fingerprint.fileTree.slice(0, 50).join("\n")}`);
+  }
+  if (allDeps.length > 0) {
+    parts.push(`
+Dependencies: ${allDeps.join(", ")}`);
+  }
+  return parts.join("\n");
+}
+async function generateSkill(context, topic, model) {
+  const prompt = `PROJECT CONTEXT:
+${context}
+
+SKILL TO GENERATE:
+Name: ${topic.name}
+Description: ${topic.description}
+
+Generate the skill content following the instructions in the system prompt.`;
+  const result = await llmJsonCall({
+    system: SKILL_GENERATION_PROMPT,
+    prompt,
+    maxTokens: 4e3,
+    ...model ? { model } : {}
+  });
+  const content = result.content?.trim();
+  if (!content) {
+    throw new Error(`Empty skill content for ${topic.name}`);
+  }
+  return {
+    name: result.name || topic.name,
+    description: result.description || topic.description,
+    content
+  };
+}
+async function generateCore(fingerprint, targetAgent, prompt, callbacks, failingChecks, currentScore, passingChecks) {
+  const provider = getProvider();
+  const userMessage = buildGeneratePrompt(fingerprint, targetAgent, prompt, failingChecks, currentScore, passingChecks);
+  let attempt = 0;
+  const attemptGeneration = async () => {
+    attempt++;
+    const maxTokensForAttempt = Math.min(
+      CORE_MAX_TOKENS + attempt * 8e3,
+      GENERATION_MAX_TOKENS
+    );
+    return new Promise((resolve2) => {
+      let preJsonBuffer = "";
+      let jsonContent = "";
+      let inJson = false;
+      let sentStatuses = 0;
+      let stopReason = null;
+      provider.stream(
+        {
+          system: CORE_GENERATION_PROMPT,
+          prompt: userMessage,
+          maxTokens: maxTokensForAttempt
+        },
+        {
+          onText: (text) => {
+            if (!inJson) {
+              preJsonBuffer += text;
+              const lines = preJsonBuffer.split("\n");
+              const completedLines = lines.slice(0, -1);
+              for (let i = sentStatuses; i < completedLines.length; i++) {
+                const trimmed = completedLines[i].trim();
+                if (trimmed.startsWith("STATUS:")) {
+                  const status = trimmed.slice(7).trim();
+                  if (status && callbacks) callbacks.onStatus(status);
+                }
+              }
+              sentStatuses = completedLines.length;
+              const jsonStartMatch = preJsonBuffer.match(/(?:^|\n)\s*(?:```json\s*\n\s*)?\{(?=\s*")/);
+              if (jsonStartMatch) {
+                const matchIndex = preJsonBuffer.indexOf("{", jsonStartMatch.index);
+                inJson = true;
+                jsonContent = preJsonBuffer.slice(matchIndex);
+              }
+            } else {
+              jsonContent += text;
+            }
+          },
+          onEnd: (meta) => {
+            stopReason = meta?.stopReason ?? null;
+            let setup = null;
+            let jsonToParse = (jsonContent || preJsonBuffer).replace(/```\s*$/g, "").trim();
+            if (!jsonContent && preJsonBuffer) {
+              const fallbackMatch = preJsonBuffer.match(/(?:^|\n)\s*(?:```json\s*\n\s*)?\{(?=\s*")/);
+              if (fallbackMatch) {
+                const matchIndex = preJsonBuffer.indexOf("{", fallbackMatch.index);
+                jsonToParse = preJsonBuffer.slice(matchIndex).replace(/```\s*$/g, "").trim();
+              }
+            }
+            try {
+              setup = JSON.parse(jsonToParse);
+            } catch {
+            }
+            if (!setup && stopReason === "max_tokens" && attempt < MAX_RETRIES2) {
+              if (callbacks) callbacks.onStatus("Output was truncated, retrying with higher token limit...");
+              setTimeout(() => attemptGeneration().then(resolve2), 1e3);
+              return;
+            }
+            let explanation;
+            const explainMatch = preJsonBuffer.match(/EXPLAIN:\s*\n([\s\S]*?)(?=\n\s*(`{3}|\{))/);
+            if (explainMatch) {
+              explanation = explainMatch[1].trim();
+            }
+            if (setup) {
+              if (callbacks) callbacks.onComplete(setup, explanation);
+              resolve2({ setup, explanation, stopReason: stopReason ?? void 0 });
+            } else {
+              resolve2({ setup: null, explanation, raw: preJsonBuffer, stopReason: stopReason ?? void 0 });
+            }
+          },
+          onError: (error) => {
+            if (isTransientError2(error) && attempt < MAX_RETRIES2) {
+              if (callbacks) callbacks.onStatus("Connection interrupted, retrying...");
+              setTimeout(() => attemptGeneration().then(resolve2), 2e3);
+              return;
+            }
+            if (callbacks) callbacks.onError(error.message);
+            resolve2({ setup: null, raw: error.message, stopReason: "error" });
+          }
+        }
+      ).catch((error) => {
+        if (callbacks) callbacks.onError(error.message);
+        resolve2({ setup: null, raw: error.message, stopReason: "error" });
+      });
+    });
+  };
+  return attemptGeneration();
+}
+async function generateMonolithic(fingerprint, targetAgent, prompt, callbacks, failingChecks, currentScore, passingChecks) {
   const provider = getProvider();
   const userMessage = buildGeneratePrompt(fingerprint, targetAgent, prompt, failingChecks, currentScore, passingChecks);
   let attempt = 0;
@@ -1910,9 +2348,9 @@ async function generateSetup(fingerprint, targetAgent, prompt, callbacks, failin
             }
             if (setup) {
               if (callbacks) callbacks.onComplete(setup, explanation);
-              resolve2({ setup, explanation });
+              resolve2({ setup, explanation, stopReason: stopReason ?? void 0 });
             } else {
-              resolve2({ setup: null, explanation, raw: preJsonBuffer });
+              resolve2({ setup: null, explanation, raw: preJsonBuffer, stopReason: stopReason ?? void 0 });
             }
           },
           onError: (error) => {
@@ -1922,12 +2360,12 @@ async function generateSetup(fingerprint, targetAgent, prompt, callbacks, failin
               return;
             }
             if (callbacks) callbacks.onError(error.message);
-            resolve2({ setup: null, raw: error.message });
+            resolve2({ setup: null, raw: error.message, stopReason: "error" });
           }
         }
       ).catch((error) => {
         if (callbacks) callbacks.onError(error.message);
-        resolve2({ setup: null, raw: error.message });
+        resolve2({ setup: null, raw: error.message, stopReason: "error" });
       });
     });
   };
@@ -5558,6 +5996,7 @@ async function initCommand(options) {
   genMessages.start();
   let generatedSetup = null;
   let rawOutput;
+  let genStopReason;
   try {
     const result = await generateSetup(
       fingerprint,
@@ -5583,15 +6022,18 @@ async function initCommand(options) {
       generatedSetup = result.setup;
       rawOutput = result.raw;
     }
+    genStopReason = result.stopReason;
   } catch (err) {
     genMessages.stop();
     const msg = err instanceof Error ? err.message : "Unknown error";
     genSpinner.fail(`Generation failed: ${msg}`);
+    writeErrorLog(config, void 0, msg, "exception");
     throw new Error("__exit__");
   }
   genMessages.stop();
   if (!generatedSetup) {
     genSpinner.fail("Failed to generate setup.");
+    writeErrorLog(config, rawOutput, void 0, genStopReason);
     if (rawOutput) {
       console.log(chalk8.dim("\nRaw LLM output (JSON parse failed):"));
       console.log(chalk8.dim(rawOutput.slice(0, 500)));
@@ -5760,7 +6202,8 @@ async function initCommand(options) {
           },
           polishFailing,
           afterScore.score,
-          polishPassing
+          polishPassing,
+          { skipSkills: true }
         );
         if (polishResult.setup) {
           const polishWriteResult = writeSetup(polishResult.setup);
@@ -5825,6 +6268,9 @@ async function initCommand(options) {
   console.log(`    ${title("caliber skills")}         Discover community skills for your stack`);
   console.log(`    ${title("caliber undo")}         Revert all changes from this run`);
   console.log("");
+  if (options.showTokens) {
+    displayTokenUsage();
+  }
   if (report) {
     report.markStep("Finished");
     const reportPath = path19.join(process.cwd(), ".caliber", "debug-report.md");
@@ -6101,6 +6547,48 @@ function ensurePermissions() {
   if (!fs24.existsSync(".claude")) fs24.mkdirSync(".claude", { recursive: true });
   fs24.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
+function displayTokenUsage() {
+  const summary = getUsageSummary();
+  if (summary.length === 0) {
+    console.log(chalk8.dim("  Token tracking not available for this provider.\n"));
+    return;
+  }
+  console.log(chalk8.bold("  Token usage:\n"));
+  let totalIn = 0;
+  let totalOut = 0;
+  for (const m of summary) {
+    totalIn += m.inputTokens;
+    totalOut += m.outputTokens;
+    const cacheInfo = m.cacheReadTokens > 0 || m.cacheWriteTokens > 0 ? chalk8.dim(` (cache: ${m.cacheReadTokens.toLocaleString()} read, ${m.cacheWriteTokens.toLocaleString()} write)`) : "";
+    console.log(`    ${chalk8.dim(m.model)}: ${m.inputTokens.toLocaleString()} in / ${m.outputTokens.toLocaleString()} out  (${m.calls} call${m.calls === 1 ? "" : "s"})${cacheInfo}`);
+  }
+  if (summary.length > 1) {
+    console.log(`    ${chalk8.dim("Total")}: ${totalIn.toLocaleString()} in / ${totalOut.toLocaleString()} out`);
+  }
+  console.log("");
+}
+function writeErrorLog(config, rawOutput, error, stopReason) {
+  try {
+    const logPath = path19.join(process.cwd(), ".caliber", "error-log.md");
+    const lines = [
+      `# Generation Error \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      "",
+      `**Provider**: ${config.provider}`,
+      `**Model**: ${config.model}`,
+      `**Stop reason**: ${stopReason || "unknown"}`,
+      ""
+    ];
+    if (error) {
+      lines.push("## Error", "```", error, "```", "");
+    }
+    lines.push("## Raw LLM Output", "```", rawOutput || "(empty)", "```");
+    fs24.mkdirSync(path19.join(process.cwd(), ".caliber"), { recursive: true });
+    fs24.writeFileSync(logPath, lines.join("\n"));
+    console.log(chalk8.dim(`
+  Error log written to .caliber/error-log.md`));
+  } catch {
+  }
+}
 
 // src/commands/undo.ts
 import chalk9 from "chalk";
@@ -7265,7 +7753,7 @@ function parseAgentOption(value) {
   }
   return agents;
 }
-program.command("init").description("Initialize your project for AI-assisted development").option("--agent <type>", "Target agents (comma-separated): claude, cursor, codex", parseAgentOption).option("--dry-run", "Preview changes without writing files").option("--force", "Overwrite existing setup without prompting").option("--debug-report", void 0, false).action(tracked("init", initCommand));
+program.command("init").description("Initialize your project for AI-assisted development").option("--agent <type>", "Target agents (comma-separated): claude, cursor, codex", parseAgentOption).option("--dry-run", "Preview changes without writing files").option("--force", "Overwrite existing setup without prompting").option("--debug-report", void 0, false).option("--show-tokens", "Show token usage summary at the end").action(tracked("init", initCommand));
 program.command("undo").description("Revert all config changes made by Caliber").action(tracked("undo", undoCommand));
 program.command("status").description("Show current Caliber setup status").option("--json", "Output as JSON").action(tracked("status", statusCommand));
 program.command("regenerate").alias("regen").alias("re").description("Re-analyze project and regenerate setup").option("--dry-run", "Preview changes without writing files").action(tracked("regenerate", regenerateCommand));

package/package.json

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