@rely-ai/caliber 1.9.0 → 1.10.1

package/dist/bin.js

@@ -1592,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.
@@ -1827,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";
@@ -1920,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;
@@ -1927,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 || options?.forceTargetedFix;
+  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;
@@ -5854,7 +6202,8 @@ async function initCommand(options) {
           },
           polishFailing,
           afterScore.score,
-          polishPassing
+          polishPassing,
+          { skipSkills: true, forceTargetedFix: true }
         );
         if (polishResult.setup) {
           const polishWriteResult = writeSetup(polishResult.setup);
@@ -6200,7 +6549,10 @@ function ensurePermissions() {
 }
 function displayTokenUsage() {
   const summary = getUsageSummary();
-  if (summary.length === 0) return;
+  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;

package/package.json

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