@rely-ai/caliber 0.4.6 → 0.5.1

package/dist/bin.js

@@ -4474,7 +4474,7 @@ async function regenerateCommand(options) {
 // src/commands/recommend.ts
 import chalk8 from "chalk";
 import ora4 from "ora";
-import { mkdirSync, readFileSync as readFileSync7, existsSync as existsSync9, writeFileSync } from "fs";
+import { mkdirSync, readFileSync as readFileSync7, readdirSync as readdirSync5, existsSync as existsSync9, writeFileSync } from "fs";
 import { join as join8, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
@@ -4608,25 +4608,78 @@ function getSkillPath(platform, slug) {
   }
   return join8(".claude", "skills", slug, "SKILL.md");
 }
-async function searchSkills(technologies) {
-  const results = [];
-  const seen = /* @__PURE__ */ new Set();
+function getInstalledSkills() {
+  const installed = /* @__PURE__ */ new Set();
+  const dirs = [
+    join8(process.cwd(), ".claude", "skills"),
+    join8(process.cwd(), ".cursor", "skills")
+  ];
+  for (const dir of dirs) {
+    try {
+      const entries = readdirSync5(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          installed.add(entry.name.toLowerCase());
+        }
+      }
+    } catch {
+    }
+  }
+  return installed;
+}
+async function searchSkillsSh(technologies) {
+  const bestBySlug = /* @__PURE__ */ new Map();
   for (const tech of technologies) {
     try {
-      const resp = await fetch(`https://api.skills.sh/v1/search?q=${encodeURIComponent(tech)}&limit=10`);
+      const resp = await fetch(`https://skills.sh/api/search?q=${encodeURIComponent(tech)}&limit=10`, {
+        signal: AbortSignal.timeout(1e4)
+      });
       if (!resp.ok) continue;
       const data = await resp.json();
       if (!data.skills?.length) continue;
       for (const skill of data.skills) {
-        if (seen.has(skill.slug)) continue;
-        seen.add(skill.slug);
-        results.push({
+        const existing = bestBySlug.get(skill.skillId);
+        if (existing && existing.installs >= (skill.installs ?? 0)) continue;
+        bestBySlug.set(skill.skillId, {
           name: skill.name,
-          slug: skill.slug,
-          source_url: skill.repo,
+          slug: skill.skillId,
+          source_url: skill.source ? `https://github.com/${skill.source}` : "",
           score: 0,
           reason: skill.description || "",
           detected_technology: tech,
+          item_type: "skill",
+          installs: skill.installs ?? 0
+        });
+      }
+    } catch {
+      continue;
+    }
+  }
+  return Array.from(bestBySlug.values());
+}
+async function searchTessl(technologies) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const tech of technologies) {
+    try {
+      const resp = await fetch(`https://tessl.io/registry?q=${encodeURIComponent(tech)}`, {
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!resp.ok) continue;
+      const html = await resp.text();
+      const linkMatches = html.matchAll(/\/registry\/skills\/github\/([^/]+)\/([^/]+)\/([^/"]+)/g);
+      for (const match of linkMatches) {
+        const [, org, repo, skillName] = match;
+        const slug = `${org}-${repo}-${skillName}`.toLowerCase();
+        if (seen.has(slug)) continue;
+        seen.add(slug);
+        results.push({
+          name: skillName,
+          slug,
+          source_url: `https://github.com/${org}/${repo}`,
+          score: 0,
+          reason: `Skill from ${org}/${repo}`,
+          detected_technology: tech,
           item_type: "skill"
         });
       }
@@ -4636,12 +4689,200 @@ async function searchSkills(technologies) {
   }
   return results;
 }
+var AWESOME_CLAUDE_CODE_URL = "https://raw.githubusercontent.com/hesreallyhim/awesome-claude-code/main/README.md";
+async function searchAwesomeClaudeCode(technologies) {
+  try {
+    const resp = await fetch(AWESOME_CLAUDE_CODE_URL, {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!resp.ok) return [];
+    const markdown = await resp.text();
+    const items = [];
+    const itemPattern = /^[-*]\s+\[([^\]]+)\]\(([^)]+)\)(?:\s+by\s+\[[^\]]*\]\([^)]*\))?\s*[-–—:]\s*(.*)/gm;
+    let match;
+    while ((match = itemPattern.exec(markdown)) !== null) {
+      const [, name, url, description] = match;
+      if (url.startsWith("#")) continue;
+      const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+      items.push({
+        name: name.trim(),
+        slug,
+        source_url: url.trim(),
+        score: 0,
+        reason: description.trim().slice(0, 150),
+        detected_technology: "claude-code",
+        item_type: "skill"
+      });
+    }
+    const techLower = technologies.map((t) => t.toLowerCase());
+    return items.filter((item) => {
+      const text = `${item.name} ${item.reason}`.toLowerCase();
+      return techLower.some((t) => text.includes(t));
+    });
+  } catch {
+    return [];
+  }
+}
+async function searchAllProviders(technologies, platform) {
+  const searches = [
+    searchSkillsSh(technologies),
+    searchTessl(technologies)
+  ];
+  if (platform === "claude" || !platform) {
+    searches.push(searchAwesomeClaudeCode(technologies));
+  }
+  const results = await Promise.all(searches);
+  const seen = /* @__PURE__ */ new Set();
+  const combined = [];
+  for (const batch of results) {
+    for (const result of batch) {
+      const key = result.name.toLowerCase().replace(/[-_]/g, "");
+      if (seen.has(key)) continue;
+      seen.add(key);
+      combined.push(result);
+    }
+  }
+  return combined;
+}
+async function scoreWithLLM(candidates, projectContext, technologies) {
+  const candidateList = candidates.map((c, i) => `${i}. "${c.name}" \u2014 ${c.reason || "no description"}`).join("\n");
+  const scored = await llmJsonCall({
+    system: `You evaluate whether AI agent skills and tools are relevant to a specific software project.
+Given a project context and a list of candidates, score each one's relevance from 0-100 and provide a brief reason (max 80 chars).
+
+Return a JSON array where each element has:
+- "index": the candidate's index number
+- "score": relevance score 0-100
+- "reason": one-liner explaining why it fits or doesn't
+
+Scoring guidelines:
+- 90-100: Directly matches a core technology or workflow in the project
+- 70-89: Relevant to the project's stack, patterns, or development workflow
+- 50-69: Tangentially related or generic but useful
+- 0-49: Not relevant to this project
+
+Be selective. Prefer specific, high-quality matches over generic ones.
+A skill for "React testing" is only relevant if the project uses React.
+A generic "TypeScript best practices" skill is less valuable than one targeting the project's actual framework.
+Return ONLY the JSON array.`,
+    prompt: `PROJECT CONTEXT:
+${projectContext}
+
+DETECTED TECHNOLOGIES:
+${technologies.join(", ")}
+
+CANDIDATES:
+${candidateList}`,
+    maxTokens: 8e3
+  });
+  if (!Array.isArray(scored)) return [];
+  return scored.filter((s) => s.score >= 60 && s.index >= 0 && s.index < candidates.length).sort((a, b) => b.score - a.score).slice(0, 20).map((s) => ({
+    ...candidates[s.index],
+    score: s.score,
+    reason: s.reason || candidates[s.index].reason
+  }));
+}
+function buildProjectContext(dir) {
+  const parts = [];
+  const fingerprint = collectFingerprint(dir);
+  if (fingerprint.packageName) parts.push(`Package: ${fingerprint.packageName}`);
+  if (fingerprint.languages.length > 0) parts.push(`Languages: ${fingerprint.languages.join(", ")}`);
+  if (fingerprint.frameworks.length > 0) parts.push(`Frameworks: ${fingerprint.frameworks.join(", ")}`);
+  if (fingerprint.description) parts.push(`Description: ${fingerprint.description}`);
+  if (fingerprint.fileTree.length > 0) {
+    parts.push(`
+File tree (${fingerprint.fileTree.length} files):
+${fingerprint.fileTree.slice(0, 50).join("\n")}`);
+  }
+  if (fingerprint.existingConfigs.claudeMd) {
+    parts.push(`
+Existing CLAUDE.md (first 500 chars):
+${fingerprint.existingConfigs.claudeMd.slice(0, 500)}`);
+  }
+  const deps = extractTopDeps();
+  if (deps.length > 0) {
+    parts.push(`
+Dependencies: ${deps.slice(0, 30).join(", ")}`);
+  }
+  const installed = getInstalledSkills();
+  if (installed.size > 0) {
+    parts.push(`
+Already installed skills: ${Array.from(installed).join(", ")}`);
+  }
+  return parts.join("\n");
+}
 function extractTopDeps() {
   const pkgPath = join8(process.cwd(), "package.json");
   if (!existsSync9(pkgPath)) return [];
   try {
     const pkg3 = JSON.parse(readFileSync7(pkgPath, "utf-8"));
-    return Object.keys(pkg3.dependencies ?? {});
+    const deps = Object.keys(pkg3.dependencies ?? {});
+    const trivial = /* @__PURE__ */ new Set([
+      "typescript",
+      "tslib",
+      "ts-node",
+      "tsx",
+      "prettier",
+      "eslint",
+      "@eslint/js",
+      "rimraf",
+      "cross-env",
+      "dotenv",
+      "nodemon",
+      "husky",
+      "lint-staged",
+      "commitlint",
+      "chalk",
+      "ora",
+      "commander",
+      "yargs",
+      "meow",
+      "inquirer",
+      "@inquirer/confirm",
+      "@inquirer/select",
+      "@inquirer/prompts",
+      "glob",
+      "minimatch",
+      "micromatch",
+      "diff",
+      "semver",
+      "uuid",
+      "nanoid",
+      "debug",
+      "ms",
+      "lodash",
+      "underscore",
+      "tsup",
+      "esbuild",
+      "rollup",
+      "webpack",
+      "vite",
+      "vitest",
+      "jest",
+      "mocha",
+      "chai",
+      "ava",
+      "fs-extra",
+      "mkdirp",
+      "del",
+      "rimraf",
+      "path-to-regexp",
+      "strip-ansi",
+      "ansi-colors"
+    ]);
+    const trivialPatterns = [
+      /^@types\//,
+      /^@rely-ai\//,
+      /^@caliber-ai\//,
+      /^eslint-/,
+      /^@eslint\//,
+      /^prettier-/,
+      /^@typescript-eslint\//,
+      /^@commitlint\//
+    ];
+    return deps.filter(
+      (d) => !trivial.has(d) && !trivialPatterns.some((p) => p.test(d))
+    );
   } catch {
     return [];
   }
@@ -4649,6 +4890,7 @@ function extractTopDeps() {
 async function recommendCommand(options) {
   const fingerprint = collectFingerprint(process.cwd());
   const platforms = detectLocalPlatforms();
+  const installedSkills = getInstalledSkills();
   const technologies = [...new Set([
     ...fingerprint.languages,
     ...fingerprint.frameworks,
@@ -4658,13 +4900,41 @@ async function recommendCommand(options) {
     console.log(chalk8.yellow("Could not detect any languages or dependencies. Try running from a project root."));
     throw new Error("__exit__");
   }
-  const spinner = ora4("Searching for skills...").start();
-  const results = await searchSkills(technologies);
-  if (!results.length) {
-    spinner.succeed("No skill recommendations found for your tech stack.");
+  const primaryPlatform = platforms.includes("claude") ? "claude" : platforms[0];
+  const searchSpinner = ora4("Searching skill registries...").start();
+  const allCandidates = await searchAllProviders(technologies, primaryPlatform);
+  if (!allCandidates.length) {
+    searchSpinner.succeed("No skills found matching your tech stack.");
+    return;
+  }
+  const newCandidates = allCandidates.filter((c) => !installedSkills.has(c.slug.toLowerCase()));
+  const filteredCount = allCandidates.length - newCandidates.length;
+  if (!newCandidates.length) {
+    searchSpinner.succeed(`Found ${allCandidates.length} skills \u2014 all already installed.`);
     return;
   }
-  spinner.succeed(`Found ${results.length} skill${results.length > 1 ? "s" : ""}`);
+  searchSpinner.succeed(
+    `Found ${allCandidates.length} skills` + (filteredCount > 0 ? chalk8.dim(` (${filteredCount} already installed)`) : "")
+  );
+  let results;
+  const config = loadConfig();
+  if (config) {
+    const scoreSpinner = ora4("Scoring relevance for your project...").start();
+    try {
+      const projectContext = buildProjectContext(process.cwd());
+      results = await scoreWithLLM(newCandidates, projectContext, technologies);
+      if (results.length === 0) {
+        scoreSpinner.succeed("No highly relevant skills found for your specific project.");
+        return;
+      }
+      scoreSpinner.succeed(`${results.length} relevant skill${results.length > 1 ? "s" : ""} for your project`);
+    } catch {
+      scoreSpinner.warn("Could not score relevance \u2014 showing top results");
+      results = newCandidates.slice(0, 20);
+    }
+  } else {
+    results = newCandidates.slice(0, 20);
+  }
   const selected = await interactiveSelect(results);
   if (selected?.length) {
     await installSkills(selected, platforms);
@@ -4679,17 +4949,27 @@ async function interactiveSelect(recs) {
   let cursor = 0;
   const { stdin, stdout } = process;
   let lineCount = 0;
+  const hasScores = recs.some((r) => r.score > 0);
   function render() {
     const lines = [];
     lines.push(chalk8.bold("  Recommendations"));
     lines.push("");
-    lines.push(`  ${chalk8.dim("Name".padEnd(30))} ${chalk8.dim("Technology".padEnd(18))} ${chalk8.dim("Source")}`);
+    if (hasScores) {
+      lines.push(`  ${chalk8.dim("Score".padEnd(7))} ${chalk8.dim("Name".padEnd(28))} ${chalk8.dim("Why")}`);
+    } else {
+      lines.push(`  ${chalk8.dim("Name".padEnd(30))} ${chalk8.dim("Technology".padEnd(18))} ${chalk8.dim("Source")}`);
+    }
     lines.push(chalk8.dim("  " + "\u2500".repeat(70)));
     for (let i = 0; i < recs.length; i++) {
       const rec = recs[i];
       const check = selected.has(i) ? chalk8.green("[x]") : "[ ]";
-      const ptr = i === cursor ? chalk8.cyan("\u276F") : " ";
-      lines.push(`  ${ptr} ${check} ${rec.name.padEnd(28)} ${rec.detected_technology.padEnd(16)} ${chalk8.dim(rec.source_url || "")}`);
+      const ptr = i === cursor ? chalk8.cyan(">") : " ";
+      if (hasScores) {
+        const scoreColor = rec.score >= 90 ? chalk8.green : rec.score >= 70 ? chalk8.yellow : chalk8.dim;
+        lines.push(`  ${ptr} ${check} ${scoreColor(String(rec.score).padStart(3))}   ${rec.name.padEnd(26)} ${chalk8.dim(rec.reason.slice(0, 40))}`);
+      } else {
+        lines.push(`  ${ptr} ${check} ${rec.name.padEnd(28)} ${rec.detected_technology.padEnd(16)} ${chalk8.dim(rec.source_url || "")}`);
+      }
     }
     lines.push("");
     lines.push(chalk8.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all  n none  \u23CE install  q cancel"));
@@ -4760,14 +5040,40 @@ async function interactiveSelect(recs) {
   });
 }
 async function fetchSkillContent(rec) {
-  if (rec.source_url && rec.slug) {
+  if (!rec.source_url) return null;
+  const repoPath = rec.source_url.replace("https://github.com/", "");
+  const candidates = [
+    `https://raw.githubusercontent.com/${repoPath}/HEAD/skills/${rec.slug}/SKILL.md`,
+    `https://raw.githubusercontent.com/${repoPath}/HEAD/${rec.slug}/SKILL.md`,
+    `https://raw.githubusercontent.com/${repoPath}/HEAD/.claude/skills/${rec.slug}/SKILL.md`
+  ];
+  for (const url of candidates) {
     try {
-      const url = `https://raw.githubusercontent.com/${rec.source_url}/HEAD/skills/${rec.slug}/SKILL.md`;
-      const resp = await fetch(url);
-      if (resp.ok) return await resp.text();
+      const resp = await fetch(url, { signal: AbortSignal.timeout(1e4) });
+      if (resp.ok) {
+        const text = await resp.text();
+        if (text.length > 20) return text;
+      }
     } catch {
     }
   }
+  try {
+    const resp = await fetch(
+      `https://api.github.com/repos/${repoPath}/git/trees/HEAD?recursive=1`,
+      { signal: AbortSignal.timeout(1e4) }
+    );
+    if (resp.ok) {
+      const tree = await resp.json();
+      const needle = `${rec.slug}/SKILL.md`;
+      const match = tree.tree?.find((f) => f.path.endsWith(needle));
+      if (match) {
+        const rawUrl = `https://raw.githubusercontent.com/${repoPath}/HEAD/${match.path}`;
+        const contentResp = await fetch(rawUrl, { signal: AbortSignal.timeout(1e4) });
+        if (contentResp.ok) return await contentResp.text();
+      }
+    }
+  } catch {
+  }
   return null;
 }
 async function installSkills(recs, platforms) {
@@ -4802,17 +5108,19 @@ async function installSkills(recs, platforms) {
   console.log("");
 }
 function printRecommendations(recs) {
+  const hasScores = recs.some((r) => r.score > 0);
   console.log(chalk8.bold("\n  Recommendations\n"));
-  console.log(
-    `  ${chalk8.dim("Name".padEnd(30))} ${chalk8.dim("Technology".padEnd(18))} ${chalk8.dim("Source")}`
-  );
+  if (hasScores) {
+    console.log(`  ${chalk8.dim("Score".padEnd(7))} ${chalk8.dim("Name".padEnd(28))} ${chalk8.dim("Why")}`);
+  } else {
+    console.log(`  ${chalk8.dim("Name".padEnd(30))} ${chalk8.dim("Technology".padEnd(18))} ${chalk8.dim("Source")}`);
+  }
   console.log(chalk8.dim("  " + "\u2500".repeat(70)));
   for (const rec of recs) {
-    console.log(
-      `  ${rec.name.padEnd(28)} ${rec.detected_technology.padEnd(16)} ${chalk8.dim(rec.source_url || "")}`
-    );
-    if (rec.reason) {
-      console.log(`  ${chalk8.dim("  " + rec.reason)}`);
+    if (hasScores) {
+      console.log(`  ${String(rec.score).padStart(3)}   ${rec.name.padEnd(26)} ${chalk8.dim(rec.reason.slice(0, 50))}`);
+    } else {
+      console.log(`  ${rec.name.padEnd(28)} ${rec.detected_technology.padEnd(16)} ${chalk8.dim(rec.source_url || "")}`);
     }
   }
   console.log("");

package/package.json

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