skillshop 2.0.0 → 2.2.0

package/src/library.js

@@ -231,6 +231,15 @@ export function validateSkillLibrary(root = process.cwd()) {
   if (typeof pkg.name !== 'string' || !pkg.name.trim()) throw new Error('package.json must have a package name');
   const library = readSkillLibrary(packageRoot, { required: true });
   const skills = validateExports(packageRoot, pkg, library);
+  const userInstall = pkg.skillshop?.userInstall ?? [];
+  if (!Array.isArray(userInstall) || new Set(userInstall).size !== userInstall.length ||
+      userInstall.some((specifier) => {
+        try {
+          return normalizeSkillSpecifier(specifier) !== specifier || !Object.hasOwn(library.exports, specifier);
+        } catch { return true; }
+      })) {
+    throw new Error('package.json#skillshop.userInstall must list unique exported skill specifiers');
+  }
   return { packageName: pkg.name, library, skills };
 }
 

package/src/specifier.js

@@ -14,3 +14,14 @@ export function normalizeSkillSpecifier(value) {
 export function skillName(value) {
   return parseSkillSpecifier(value).name;
 }
+
+export function parseLibrarySkillReference(value) {
+  if (typeof value !== 'string') throw new TypeError('library skill reference must be a string');
+  const separator = value.lastIndexOf(':');
+  if (separator <= 0 || separator === value.length - 1) {
+    throw new Error(`Invalid library skill reference: ${value}. Expected <library>:<skill>`);
+  }
+  const library = value.slice(0, separator);
+  const skill = parseSkillSpecifier(`skill:${value.slice(separator + 1)}`);
+  return Object.freeze({ library, specifier: skill.specifier, name: skill.name });
+}

package/src/user-install.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { importSkill } from './import.js';
+import { normalizeSkillSpecifier, skillName } from './specifier.js';
+
+function declaredUserSkills(packageRoot) {
+  const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+  const declared = pkg.skillshop?.userInstall ?? [];
+  if (!Array.isArray(declared) || new Set(declared).size !== declared.length ||
+      declared.some((specifier) => {
+        try { return normalizeSkillSpecifier(specifier) !== specifier; }
+        catch { return true; }
+      })) {
+    throw new Error('package.json#skillshop.userInstall must list unique skill specifiers');
+  }
+  return declared;
+}
+
+export async function installUserSkill({
+  library,
+  specifier,
+  cwd = process.cwd(),
+  userSkillsDir = path.join(os.homedir(), '.agents', 'skills'),
+}) {
+  const normalized = normalizeSkillSpecifier(specifier);
+  return importSkill({
+    library,
+    specifier: normalized,
+    targetDir: path.resolve(userSkillsDir, skillName(normalized)),
+    cwd,
+    overwrite: true,
+  });
+}
+
+export async function installDeclaredUserSkills({
+  library = process.cwd(),
+  userSkillsDir,
+  cwd = process.cwd(),
+} = {}) {
+  const packageRoot = path.resolve(cwd, library);
+  const declared = declaredUserSkills(packageRoot);
+  const results = [];
+  for (const specifier of declared) {
+    results.push(await installUserSkill({ library: packageRoot, specifier, cwd, userSkillsDir }));
+  }
+  return results;
+}