@rely-ai/caliber 1.19.4 → 1.19.5

package/dist/bin.js

@@ -2060,39 +2060,53 @@ Return a JSON object with this exact shape:
 }
 
 Respond with ONLY the JSON object, no markdown fences or extra text.`;
-var LEARN_SYSTEM_PROMPT = `You are an expert developer experience engineer. You analyze raw tool call events from AI coding sessions to extract reusable lessons that will improve future sessions.
+var LEARN_SYSTEM_PROMPT = `You are an expert developer experience engineer. You analyze raw tool call events from AI coding sessions to extract reusable operational lessons that will help future LLM sessions work more effectively in this project.
 
 You receive a chronological sequence of tool events from a Claude Code session. Each event includes the tool name, its input, its response, and whether it was a success or failure.
 
-Your job is to reason deeply about these events and identify:
+Your job is to find OPERATIONAL patterns \u2014 things that went wrong and how they were fixed, commands that required specific flags or configuration, APIs that needed a particular approach to work. Focus on the WORKFLOW, not the code logic.
 
-1. **Failure patterns**: Tools that failed and why \u2014 incorrect commands, wrong file paths, missing dependencies, syntax errors, permission issues
-2. **Recovery patterns**: How failures were resolved \u2014 what approach worked after one or more failures
-3. **Workarounds**: When the agent had to abandon one approach entirely and use a different strategy
-4. **Repeated struggles**: The same tool being called many times against the same target, indicating confusion or trial-and-error
-5. **Project-specific conventions**: Commands, paths, patterns, or configurations that are specific to this project and would help future sessions
-6. **Anti-patterns**: Commands, approaches, or configurations that consistently fail or cause problems \u2014 things future sessions should explicitly avoid
+Look for:
+
+1. **Failure \u2192 Recovery sequences**: A tool call failed, then a different approach succeeded. Document what works and what doesn't. Example: an API call failed with one config but succeeded with different headers or parameters.
+2. **Environment gotchas**: Commands that need specific env vars, flags, or preconditions to work in this project.
+3. **Retry patterns**: When something had to be called multiple times with different arguments before succeeding.
+4. **Project-specific commands**: The correct way to build, test, lint, deploy \u2014 especially if it differs from defaults.
+5. **File/path traps**: Paths that are misleading, files that shouldn't be edited, directories with unexpected structure.
+6. **Configuration quirks**: Settings, flags, or arguments that are required but non-obvious.
+
+DO NOT extract:
+- Descriptions of what the code does or how features work (e.g. "compression removes comments" or "skeleton extraction creates outlines")
+- General programming best practices everyone already knows
+- Summaries of successful routine operations that need no special handling
+- Anything already covered in the existing CLAUDE.md
 
 From these observations, produce:
 
 ### claudeMdLearnedSection
-A markdown section with concise, actionable bullet points. Your output will be written to CALIBER_LEARNINGS.md \u2014 a standalone file that all AI coding agents (Claude Code, Cursor, Codex) reference for project-specific patterns and anti-patterns. Each bullet should be a concrete instruction that prevents a past mistake or encodes a discovered convention. Examples:
-- "Always run \`npm install\` before \`npm run build\` in this project"
+A markdown section with concise, actionable bullet points. Your output will be written to CALIBER_LEARNINGS.md \u2014 a standalone file that all AI coding agents (Claude Code, Cursor, Codex) reference for project-specific operational patterns. Each bullet should be a concrete instruction that prevents a future mistake or encodes a discovered workaround. Format: what to do (or avoid), and why.
+
+Good examples:
+- "Run \`npm install\` before \`npm run build\` \u2014 the build assumes deps are installed and gives a misleading error otherwise"
 - "The test database requires \`DATABASE_URL\` to be set \u2014 use \`source .env.test\` first"
-- "TypeScript strict mode is enabled \u2014 never use \`any\`, use \`unknown\` with type guards"
-- "Use \`pnpm\` not \`npm\` \u2014 the lockfile is pnpm-lock.yaml"
-- "Never use \`npm\` in this project \u2014 pnpm-lock.yaml is the lockfile"
-- "Do NOT run \`jest\` directly \u2014 always use \`npm run test\` which sets the correct env"
-- "Avoid modifying files in \`src/generated/\` \u2014 they are auto-generated by the build step"
+- "Use \`pnpm\` not \`npm\` \u2014 the lockfile is pnpm-lock.yaml and npm creates conflicts"
+- "Do NOT run \`jest\` directly \u2014 always use \`npm run test\` which sets the correct NODE_ENV"
+- "API calls to \`/v2/users\` require the \`X-Api-Version\` header \u2014 without it you get a 404 that looks like the endpoint doesn't exist"
+- "When \`tsup\` build fails with a type error, run \`npx tsc --noEmit\` first to get the real error \u2014 tsup swallows the details"
+- "Files in \`src/generated/\` are auto-generated \u2014 editing them directly will be overwritten on next build"
+
+Bad examples (do NOT produce these):
+- "The codebase uses TypeScript with strict mode" (describes code, not actionable)
+- "Components follow a pattern of X" (describes architecture, not operational)
+- "The project has a scoring module" (summarizes code structure)
 
 Rules for the learned section:
 - Be additive: keep all existing learned items, add new ones, remove duplicates
 - Never repeat instructions already present in the main CLAUDE.md
-- Each bullet must be specific and actionable \u2014 no vague advice
+- Each bullet must encode an operational lesson from actual events \u2014 not a code description
 - Include both positive directives ('Always do X') and negative rules ('Never do Y because Z') when the session evidence supports them
 - Maximum ~30 bullet items total
-- Group related items under subheadings if there are many
-- If there's nothing meaningful to learn, return null
+- If there's nothing operationally meaningful to learn, return null \u2014 this is perfectly fine
 
 ### skills
 Only create a skill when there's enough domain-specific knowledge to warrant a dedicated file (e.g., a specific build process, a testing pattern, a deployment workflow). Most sessions won't produce skills.
@@ -8127,7 +8141,14 @@ function readAllEvents() {
   const filePath = sessionFilePath();
   if (!fs30.existsSync(filePath)) return [];
   const lines = fs30.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
-  return lines.map((line) => JSON.parse(line));
+  const events = [];
+  for (const line of lines) {
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return events;
 }
 function getEventCount() {
   const filePath = sessionFilePath();
@@ -8271,7 +8292,7 @@ ${eventsText}`;
 
 // src/commands/learn.ts
 init_config();
-var MIN_EVENTS_FOR_ANALYSIS = 50;
+var MIN_EVENTS_FOR_ANALYSIS = 25;
 async function learnObserveCommand(options) {
   try {
     const raw = await readStdin();
@@ -8298,19 +8319,29 @@ async function learnObserveCommand(options) {
 async function learnFinalizeCommand(options) {
   if (!options?.force) {
     const { isCaliberRunning: isCaliberRunning2 } = await Promise.resolve().then(() => (init_lock(), lock_exports));
-    if (isCaliberRunning2()) return;
+    if (isCaliberRunning2()) {
+      console.log(chalk17.dim("caliber: skipping finalize \u2014 another caliber process is running"));
+      return;
+    }
+  }
+  if (!acquireFinalizeLock()) {
+    console.log(chalk17.dim("caliber: skipping finalize \u2014 another finalize is in progress"));
+    return;
   }
-  if (!acquireFinalizeLock()) return;
   let analyzed = false;
   try {
     const config = loadConfig();
     if (!config) {
+      console.log(chalk17.yellow("caliber: no LLM provider configured \u2014 run `caliber config` first"));
       clearSession();
       resetState();
       return;
     }
     const events = readAllEvents();
-    if (events.length < MIN_EVENTS_FOR_ANALYSIS) return;
+    if (events.length < MIN_EVENTS_FOR_ANALYSIS) {
+      console.log(chalk17.dim(`caliber: ${events.length}/${MIN_EVENTS_FOR_ANALYSIS} events recorded \u2014 need more before analysis`));
+      return;
+    }
     await validateModel({ fast: true });
     migrateInlineLearnings();
     const existingConfigs = readExistingConfigs(process.cwd());
@@ -8335,7 +8366,10 @@ async function learnFinalizeCommand(options) {
         }
       }
     }
-  } catch {
+  } catch (err) {
+    if (options?.force) {
+      console.error(chalk17.red("caliber: finalize failed \u2014"), err instanceof Error ? err.message : err);
+    }
   } finally {
     if (analyzed) {
       clearSession();

package/package.json

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