skills 1.0.11 → 1.0.13

package/dist/cli.js

@@ -1,9 +1,18 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { spawn } from "child_process";
-import { writeFileSync, existsSync, mkdirSync } from "fs";
+import { spawn, spawnSync } from "child_process";
+import {
+  writeFileSync,
+  readFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  statSync
+} from "fs";
 import { basename, join } from "path";
+import { homedir } from "os";
+import { createHash } from "crypto";
 var RESET = "\x1B[0m";
 var BOLD = "\x1B[1m";
 var DIM = "\x1B[38;5;102m";
@@ -53,14 +62,22 @@ ${BOLD}Commands:${RESET}
   add <package>     Add a skill package
                     e.g. vercel-labs/agent-skills
                          https://github.com/vercel-labs/agent-skills
+  check             Check for available skill updates
+  update            Update all skills to latest versions
+  generate-lock     Generate lock file from installed skills
 
 ${BOLD}Options:${RESET}
   --help, -h        Show this help message
   --version, -v     Show version number
+  --refresh, -r     Force refresh from source (check)
+  --dry-run         Preview changes without writing (generate-lock)
 
 ${BOLD}Examples:${RESET}
   ${DIM}$${RESET} skills init my-skill
   ${DIM}$${RESET} skills add vercel-labs/agent-skills
+  ${DIM}$${RESET} skills check
+  ${DIM}$${RESET} skills update
+  ${DIM}$${RESET} skills generate-lock --dry-run
 
 Discover more skills at ${TEXT}https://skills.sh/${RESET}
 `);
@@ -72,7 +89,10 @@ function getOwnerRepo(pkg) {
   }
   const githubMatch = pkg.match(/github\.com\/([^\/]+)\/([^\/]+)/);
   if (githubMatch && githubMatch[1] && githubMatch[2]) {
-    return { owner: githubMatch[1], repo: githubMatch[2].replace(/\.git$/, "") };
+    return {
+      owner: githubMatch[1],
+      repo: githubMatch[2].replace(/\.git$/, "")
+    };
   }
   return null;
 }
@@ -160,6 +180,343 @@ Describe when this skill should be used.
   console.log(`Browse existing skills for inspiration at ${TEXT}https://skills.sh/${RESET}`);
   console.log();
 }
+var AGENTS_DIR = ".agents";
+var SKILLS_SUBDIR = "skills";
+var LOCK_FILE = ".skill-lock.json";
+var SEARCH_API_URL = "https://skills.sh/api/skills/search";
+var CHECK_UPDATES_API_URL = "https://add-skill.vercel.sh/check-updates";
+var CURRENT_LOCK_VERSION = 2;
+function getSkillLockPath() {
+  return join(homedir(), AGENTS_DIR, LOCK_FILE);
+}
+function readSkillLock() {
+  const lockPath = getSkillLockPath();
+  try {
+    const content = readFileSync(lockPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed.version !== "number" || !parsed.skills) {
+      return { version: CURRENT_LOCK_VERSION, skills: {} };
+    }
+    if (parsed.version < CURRENT_LOCK_VERSION) {
+      return { version: CURRENT_LOCK_VERSION, skills: {} };
+    }
+    return parsed;
+  } catch {
+    return { version: CURRENT_LOCK_VERSION, skills: {} };
+  }
+}
+function writeSkillLock(lock) {
+  const lockPath = getSkillLockPath();
+  const dir = join(homedir(), AGENTS_DIR);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(lockPath, JSON.stringify(lock, null, 2), "utf-8");
+}
+function getInstalledSkillNames() {
+  const skillsDir = join(homedir(), AGENTS_DIR, SKILLS_SUBDIR);
+  const skillNames = [];
+  try {
+    const entries = readdirSync(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() || entry.isSymbolicLink()) {
+        const skillMdPath = join(skillsDir, entry.name, "SKILL.md");
+        try {
+          const stat = statSync(skillMdPath);
+          if (stat.isFile()) {
+            skillNames.push(entry.name);
+          }
+        } catch {
+          try {
+            const contents = readdirSync(join(skillsDir, entry.name));
+            if (contents.length > 0) {
+              skillNames.push(entry.name);
+            }
+          } catch {}
+        }
+      }
+    }
+  } catch {}
+  return skillNames;
+}
+async function fuzzyMatchSkills(skillNames, apiUrl = SEARCH_API_URL) {
+  if (skillNames.length === 0)
+    return {};
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ skills: skillNames })
+  });
+  if (!response.ok) {
+    throw new Error(`API request failed: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.matches;
+}
+function inferSourceType(source) {
+  if (source.startsWith("mintlify/"))
+    return "mintlify";
+  if (source.startsWith("huggingface/"))
+    return "huggingface";
+  return "github";
+}
+function buildSourceUrl(source, sourceType) {
+  switch (sourceType) {
+    case "github":
+      return `https://github.com/${source}.git`;
+    case "mintlify":
+      return source;
+    case "huggingface":
+      const parts = source.replace("huggingface/", "").split("/");
+      return `https://huggingface.co/spaces/${parts.join("/")}`;
+    default:
+      return source;
+  }
+}
+async function runGenerateLock(args) {
+  const dryRun = args.includes("--dry-run");
+  const apiUrlIdx = args.indexOf("--api-url");
+  const apiUrl = apiUrlIdx !== -1 && args[apiUrlIdx + 1] ? args[apiUrlIdx + 1] : SEARCH_API_URL;
+  console.log(`${TEXT}Scanning for installed skills...${RESET}`);
+  const installedSkills = getInstalledSkillNames();
+  if (installedSkills.length === 0) {
+    console.log(`${DIM}No installed skills found.${RESET}`);
+    return;
+  }
+  console.log(`${DIM}Found ${installedSkills.length} installed skill(s)${RESET}`);
+  console.log();
+  const existingLock = readSkillLock();
+  const existingCount = Object.keys(existingLock.skills).length;
+  const skillsToMatch = installedSkills.filter((skill) => !(skill in existingLock.skills));
+  if (skillsToMatch.length === 0) {
+    console.log(`${TEXT}All skills already in lock file.${RESET}`);
+    return;
+  }
+  console.log(`${TEXT}Matching ${skillsToMatch.length} skill(s) against database...${RESET}`);
+  console.log();
+  const matches = await fuzzyMatchSkills(skillsToMatch, apiUrl);
+  const now = new Date().toISOString();
+  const updatedLock = { ...existingLock };
+  let matchedCount = 0;
+  let skippedCount = 0;
+  const EXACT_MATCH_THRESHOLD = 1000;
+  for (const skillName of skillsToMatch) {
+    const match = matches[skillName];
+    if (match && match.score >= EXACT_MATCH_THRESHOLD) {
+      matchedCount++;
+      const sourceType = inferSourceType(match.source);
+      const sourceUrl = match.sourceUrl || buildSourceUrl(match.source, sourceType);
+      console.log(`${TEXT}✓${RESET} ${skillName}`);
+      console.log(`  ${DIM}source: ${match.source}${RESET}`);
+      updatedLock.skills[skillName] = {
+        source: match.source,
+        sourceType,
+        sourceUrl,
+        contentHash: "",
+        installedAt: now,
+        updatedAt: now
+      };
+    } else {
+      skippedCount++;
+    }
+  }
+  console.log();
+  console.log(`${TEXT}Matched:${RESET} ${matchedCount}`);
+  console.log(`${DIM}Skipped: ${skippedCount} (no exact match)${RESET}`);
+  console.log();
+  if (matchedCount === 0) {
+    console.log(`${DIM}No new skills to add to lock file.${RESET}`);
+    return;
+  }
+  if (dryRun) {
+    console.log(`${DIM}Dry run - no changes written${RESET}`);
+    console.log();
+    console.log(JSON.stringify(updatedLock, null, 2));
+  } else {
+    writeSkillLock(updatedLock);
+    console.log(`${TEXT}Lock file updated:${RESET} ${DIM}~/.agents/.skill-lock.json${RESET}`);
+  }
+}
+function computeContentHash(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function getSkillContentPath(skillName) {
+  return join(homedir(), AGENTS_DIR, SKILLS_SUBDIR, skillName, "SKILL.md");
+}
+function readSkillContent(skillName) {
+  const skillPath = getSkillContentPath(skillName);
+  try {
+    return readFileSync(skillPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function runCheck(args = []) {
+  const forceRefresh = args.includes("--refresh") || args.includes("-r");
+  console.log(`${TEXT}Checking for skill updates...${RESET}`);
+  console.log();
+  const lock = readSkillLock();
+  const skillNames = Object.keys(lock.skills);
+  if (skillNames.length === 0) {
+    console.log(`${DIM}No skills tracked in lock file.${RESET}`);
+    console.log(`${DIM}Install skills with${RESET} ${TEXT}npx skills add <package>${RESET}`);
+    return;
+  }
+  const checkRequest = {
+    skills: []
+  };
+  if (forceRefresh) {
+    checkRequest.forceRefresh = true;
+  }
+  for (const skillName of skillNames) {
+    const entry = lock.skills[skillName];
+    if (!entry)
+      continue;
+    let contentHash = entry.contentHash;
+    if (!contentHash) {
+      const content = readSkillContent(skillName);
+      if (content) {
+        contentHash = computeContentHash(content);
+      } else {
+        console.log(`${DIM}Skipping ${skillName}: cannot read SKILL.md${RESET}`);
+        continue;
+      }
+    }
+    checkRequest.skills.push({
+      name: skillName,
+      source: entry.source,
+      path: entry.skillPath,
+      contentHash
+    });
+  }
+  if (checkRequest.skills.length === 0) {
+    console.log(`${DIM}No skills to check.${RESET}`);
+    return;
+  }
+  console.log(`${DIM}Checking ${checkRequest.skills.length} skill(s) for updates...${RESET}`);
+  try {
+    const response = await fetch(CHECK_UPDATES_API_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(checkRequest)
+    });
+    if (!response.ok) {
+      throw new Error(`API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    console.log();
+    if (data.updates.length === 0) {
+      console.log(`${TEXT}✓ All skills are up to date${RESET}`);
+    } else {
+      console.log(`${TEXT}${data.updates.length} update(s) available:${RESET}`);
+      console.log();
+      for (const update of data.updates) {
+        console.log(`  ${TEXT}↑${RESET} ${update.name}`);
+        console.log(`    ${DIM}source: ${update.source}${RESET}`);
+      }
+      console.log();
+      console.log(`${DIM}Run${RESET} ${TEXT}npx skills update${RESET} ${DIM}to update all skills${RESET}`);
+    }
+    if (data.errors && data.errors.length > 0) {
+      console.log();
+      console.log(`${DIM}Could not check ${data.errors.length} skill(s):${RESET}`);
+      for (const err of data.errors) {
+        console.log(`  ${DIM}${err.name}: ${err.error}${RESET}`);
+      }
+    }
+  } catch (error) {
+    console.log(`${TEXT}Error checking for updates:${RESET} ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+  console.log();
+}
+async function runUpdate() {
+  console.log(`${TEXT}Checking for skill updates...${RESET}`);
+  console.log();
+  const lock = readSkillLock();
+  const skillNames = Object.keys(lock.skills);
+  if (skillNames.length === 0) {
+    console.log(`${DIM}No skills tracked in lock file.${RESET}`);
+    console.log(`${DIM}Install skills with${RESET} ${TEXT}npx skills add <package>${RESET}`);
+    return;
+  }
+  const checkRequest = {
+    skills: []
+  };
+  for (const skillName of skillNames) {
+    const entry = lock.skills[skillName];
+    if (!entry)
+      continue;
+    let contentHash = entry.contentHash;
+    if (!contentHash) {
+      const content = readSkillContent(skillName);
+      if (content) {
+        contentHash = computeContentHash(content);
+      } else {
+        continue;
+      }
+    }
+    checkRequest.skills.push({
+      name: skillName,
+      source: entry.source,
+      path: entry.skillPath,
+      contentHash
+    });
+  }
+  if (checkRequest.skills.length === 0) {
+    console.log(`${DIM}No skills to check.${RESET}`);
+    return;
+  }
+  let updates = [];
+  try {
+    const response = await fetch(CHECK_UPDATES_API_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(checkRequest)
+    });
+    if (!response.ok) {
+      throw new Error(`API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    updates = data.updates;
+  } catch (error) {
+    console.log(`${TEXT}Error checking for updates:${RESET} ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+  if (updates.length === 0) {
+    console.log(`${TEXT}✓ All skills are up to date${RESET}`);
+    console.log();
+    return;
+  }
+  console.log(`${TEXT}Found ${updates.length} update(s)${RESET}`);
+  console.log();
+  let successCount = 0;
+  let failCount = 0;
+  for (const update of updates) {
+    const entry = lock.skills[update.name];
+    if (!entry)
+      continue;
+    console.log(`${TEXT}Updating ${update.name}...${RESET}`);
+    const result = spawnSync("npx", ["-y", "add-skill", entry.sourceUrl, "--skill", update.name, "-g", "-y"], {
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    if (result.status === 0) {
+      successCount++;
+      console.log(`  ${TEXT}✓${RESET} Updated ${update.name}`);
+    } else {
+      failCount++;
+      console.log(`  ${DIM}✗ Failed to update ${update.name}${RESET}`);
+    }
+  }
+  console.log();
+  if (successCount > 0) {
+    console.log(`${TEXT}✓ Updated ${successCount} skill(s)${RESET}`);
+  }
+  if (failCount > 0) {
+    console.log(`${DIM}Failed to update ${failCount} skill(s)${RESET}`);
+  }
+  console.log();
+}
 function main() {
   const args = process.argv.slice(2);
   if (args.length === 0) {
@@ -182,6 +539,23 @@ function main() {
       console.log();
       runAddSkill(restArgs);
       break;
+    case "check":
+      showLogo();
+      console.log();
+      runCheck(restArgs);
+      break;
+    case "update":
+    case "upgrade":
+      showLogo();
+      console.log();
+      runUpdate();
+      break;
+    case "generate-lock":
+    case "gen-lock":
+      showLogo();
+      console.log();
+      runGenerateLock(restArgs);
+      break;
     case "--help":
     case "-h":
       showHelp();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skills",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "The open agent skills ecosystem",
   "type": "module",
   "bin": {