skills 1.0.12 → 1.0.13

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { spawn } from "child_process";
+import { spawn, spawnSync } from "child_process";
 import {
   writeFileSync,
   readFileSync,
@@ -12,6 +12,7 @@ import {
 } 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";
@@ -61,16 +62,21 @@ ${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}
@@ -178,6 +184,8 @@ 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);
 }
@@ -187,11 +195,14 @@ function readSkillLock() {
     const content = readFileSync(lockPath, "utf-8");
     const parsed = JSON.parse(content);
     if (typeof parsed.version !== "number" || !parsed.skills) {
-      return { version: 1, skills: {} };
+      return { version: CURRENT_LOCK_VERSION, skills: {} };
+    }
+    if (parsed.version < CURRENT_LOCK_VERSION) {
+      return { version: CURRENT_LOCK_VERSION, skills: {} };
     }
     return parsed;
   } catch {
-    return { version: 1, skills: {} };
+    return { version: CURRENT_LOCK_VERSION, skills: {} };
   }
 }
 function writeSkillLock(lock) {
@@ -301,6 +312,7 @@ async function runGenerateLock(args) {
         source: match.source,
         sourceType,
         sourceUrl,
+        contentHash: "",
         installedAt: now,
         updatedAt: now
       };
@@ -325,6 +337,186 @@ async function runGenerateLock(args) {
     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) {
@@ -347,6 +539,17 @@ 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();

package/package.json

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