prpm 1.0.0 → 1.0.2

package/dist/index.js

@@ -4633,8 +4633,8 @@ function loadSchema(format, subtype) {
     };
     schemaFilename = schemaMap[format] || `${format}.schema.json`;
   }
-  const schemaPath2 = (0, import_path7.join)(currentDirname, "..", "schemas", schemaFilename);
-  const schemaContent = (0, import_fs8.readFileSync)(schemaPath2, "utf-8");
+  const schemaPath = (0, import_path7.join)(currentDirname, "..", "schemas", schemaFilename);
+  const schemaContent = (0, import_fs8.readFileSync)(schemaPath, "utf-8");
   const schema3 = JSON.parse(schemaContent);
   const compiled = ajv.compile(schema3);
   schemaCache.set(cacheKey, compiled);
@@ -6730,6 +6730,7 @@ async function handleInstall(packageSpec, options) {
       packageId = parts[0];
       specVersion = parts[1];
     }
+    const config = await getConfig();
     const lockfile = await readLockfile();
     const lockedVersion = getLockedVersion(lockfile, packageId);
     let version;
@@ -6741,10 +6742,15 @@ async function handleInstall(packageSpec, options) {
     } else {
       version = options.version || specVersion || lockedVersion || "latest";
     }
+    let targetFormat = options.as;
+    if (!targetFormat) {
+      targetFormat = config.defaultFormat || await autoDetectFormat() || void 0;
+    }
     if (!options.force && lockfile && lockfile.packages[packageId]) {
       const installedPkg = lockfile.packages[packageId];
       const requestedVersion = options.version || specVersion;
-      if (!requestedVersion || requestedVersion === "latest" || requestedVersion === installedPkg.version) {
+      const sameFormat = !targetFormat || installedPkg.format === targetFormat;
+      if (sameFormat && (!requestedVersion || requestedVersion === "latest" || requestedVersion === installedPkg.version)) {
         console.log(`
 \u2728 Package already installed!`);
         console.log(`   \u{1F4E6} ${packageId}@${installedPkg.version}`);
@@ -6753,14 +6759,16 @@ async function handleInstall(packageSpec, options) {
 \u{1F4A1} To reinstall or upgrade:`);
         console.log(`   prpm upgrade ${packageId}     # Upgrade to latest version`);
         console.log(`   prpm uninstall ${packageId}   # Uninstall first, then install`);
+        console.log(`   prpm install ${packageId} --as <format>  # Install in different format`);
         success = true;
         return;
+      } else if (!sameFormat) {
+        console.log(`\u{1F4E6} Installing ${packageId} in ${targetFormat} format (already have ${installedPkg.format} version)`);
       } else if (requestedVersion !== installedPkg.version) {
         console.log(`\u{1F4E6} Upgrading ${packageId}: ${installedPkg.version} \u2192 ${requestedVersion}`);
       }
     }
     console.log(`\u{1F4E5} Installing ${packageId}@${version}...`);
-    const config = await getConfig();
     const client = (0, import_registry_client5.getRegistryClient)(config);
     let isCollection = false;
     try {
@@ -7210,65 +7218,90 @@ ${afterFrontmatter}`;
   }
 }
 async function extractTarball(tarball, packageId) {
-  const files = [];
   const zlib = await import("zlib");
-  const fs9 = await import("fs");
+  const fs9 = await import("fs/promises");
   const os2 = await import("os");
-  return new Promise((resolve2, reject) => {
-    zlib.gunzip(tarball, async (err, result) => {
-      if (err) {
-        reject(err);
-        return;
+  const fallback = (buffer) => [
+    {
+      name: `${packageId}.md`,
+      content: buffer.toString("utf-8")
+    }
+  ];
+  let decompressed;
+  try {
+    decompressed = await new Promise((resolve2, reject) => {
+      zlib.gunzip(tarball, (err, result) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve2(result);
+      });
+    });
+  } catch (error) {
+    throw error;
+  }
+  const tmpDir = await fs9.mkdtemp(import_path8.default.join(os2.tmpdir(), "prpm-"));
+  const cleanup = async () => {
+    try {
+      await fs9.rm(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  const excludedNames = /* @__PURE__ */ new Set([
+    "prpm.json",
+    "README",
+    "README.md",
+    "README.txt",
+    "LICENSE",
+    "LICENSE.txt",
+    "LICENSE.md"
+  ]);
+  try {
+    const extract2 = tar.extract({
+      cwd: tmpDir,
+      strict: false
+    });
+    await (0, import_promises.pipeline)(import_stream.Readable.from(decompressed), extract2);
+    const extractedFiles = await collectExtractedFiles(tmpDir, excludedNames, fs9);
+    if (extractedFiles.length === 0) {
+      return fallback(decompressed);
+    }
+    return extractedFiles;
+  } catch {
+    return fallback(decompressed);
+  } finally {
+    await cleanup();
+  }
+}
+async function collectExtractedFiles(rootDir, excludedNames, fs9) {
+  const files = [];
+  const dirs = [rootDir];
+  while (dirs.length > 0) {
+    const currentDir = dirs.pop();
+    if (!currentDir) continue;
+    const entries = await fs9.readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = import_path8.default.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        dirs.push(fullPath);
+        continue;
       }
-      const isTar = result.length > 257 && result.toString("utf-8", 257, 262) === "ustar";
-      if (!isTar) {
-        files.push({
-          name: `${packageId}.md`,
-          content: result.toString("utf-8")
-        });
-        resolve2(files);
-        return;
+      if (!entry.isFile()) {
+        continue;
       }
-      const tmpDir = await fs9.promises.mkdtemp(import_path8.default.join(os2.tmpdir(), "prpm-"));
-      try {
-        const tarPath = import_path8.default.join(tmpDir, "package.tar");
-        await fs9.promises.writeFile(tarPath, result);
-        await tar.extract({
-          file: tarPath,
-          cwd: tmpDir
-        });
-        const extractedFiles = await fs9.promises.readdir(tmpDir, { withFileTypes: true, recursive: true });
-        const excludeFiles = ["package.tar", "prpm.json", "README.md", "LICENSE", "LICENSE.txt", "LICENSE.md"];
-        for (const entry of extractedFiles) {
-          if (entry.isFile() && !excludeFiles.includes(entry.name)) {
-            const filePath = import_path8.default.join(entry.path || tmpDir, entry.name);
-            const content = await fs9.promises.readFile(filePath, "utf-8");
-            const relativePath = import_path8.default.relative(tmpDir, filePath);
-            files.push({
-              name: relativePath,
-              content
-            });
-          }
-        }
-        if (files.length === 0) {
-          files.push({
-            name: `${packageId}.md`,
-            content: result.toString("utf-8")
-          });
-        }
-        await fs9.promises.rm(tmpDir, { recursive: true, force: true });
-        resolve2(files);
-      } catch (tarErr) {
-        await fs9.promises.rm(tmpDir, { recursive: true, force: true }).catch(() => {
-        });
-        files.push({
-          name: `${packageId}.md`,
-          content: result.toString("utf-8")
-        });
-        resolve2(files);
+      if (excludedNames.has(entry.name)) {
+        continue;
       }
-    });
-  });
+      const content = await fs9.readFile(fullPath, "utf-8");
+      const relativePath = import_path8.default.relative(rootDir, fullPath).split(import_path8.default.sep).join("/");
+      files.push({
+        name: relativePath,
+        content
+      });
+    }
+  }
+  return files;
 }
 async function installFromLockfile(options) {
   var _a;
@@ -7362,7 +7395,7 @@ function createInstallCommand() {
   });
   return command;
 }
-var import_commander10, import_registry_client5, tar, import_path8;
+var import_commander10, import_registry_client5, import_stream, import_promises, tar, import_path8;
 var init_install = __esm({
   "src/commands/install.ts"() {
     "use strict";
@@ -7372,6 +7405,8 @@ var init_install = __esm({
     init_user_config();
     init_filesystem();
     init_telemetry();
+    import_stream = require("stream");
+    import_promises = require("stream/promises");
     tar = __toESM(require("tar"));
     init_errors();
     init_prompts();
@@ -9940,7 +9975,7 @@ init_install();
 // src/commands/publish.ts
 init_cjs_shims();
 var import_commander11 = require("commander");
-var import_promises4 = require("fs/promises");
+var import_promises5 = require("fs/promises");
 var import_path12 = require("path");
 var tar2 = __toESM(require("tar"));
 var import_os3 = require("os");
@@ -10116,11 +10151,23 @@ var import_ajv2 = __toESM(require("ajv"));
 var import_ajv_formats2 = __toESM(require("ajv-formats"));
 var import_fs9 = require("fs");
 var import_path9 = require("path");
-var schemaPath = (0, import_path9.join)(__dirname, "../../schemas/prpm-manifest.schema.json");
 var schema2;
-try {
-  schema2 = JSON.parse((0, import_fs9.readFileSync)(schemaPath, "utf-8"));
-} catch (error) {
+var schemaCandidates = [
+  // Source file layout (src/core → ../../schemas)
+  (0, import_path9.join)(__dirname, "../../schemas/prpm-manifest.schema.json"),
+  // Bundled layout (dist/index.js → ../schemas)
+  (0, import_path9.join)(__dirname, "../schemas/prpm-manifest.schema.json")
+];
+for (const candidate of schemaCandidates) {
+  try {
+    if ((0, import_fs9.existsSync)(candidate)) {
+      schema2 = JSON.parse((0, import_fs9.readFileSync)(candidate, "utf-8"));
+      break;
+    }
+  } catch {
+  }
+}
+if (!schema2) {
   console.warn("\u26A0\uFE0F  Could not load manifest schema, skipping schema validation");
 }
 function validateManifestSchema(manifest) {
@@ -10168,7 +10215,7 @@ function getManifestSchema() {
 
 // src/utils/license-extractor.ts
 init_cjs_shims();
-var import_promises = require("fs/promises");
+var import_promises2 = require("fs/promises");
 var import_path10 = require("path");
 var import_fs10 = require("fs");
 var LICENSE_FILE_PATTERNS = [
@@ -10221,8 +10268,8 @@ async function extractLicenseInfo(repositoryUrl) {
   for (const fileName of LICENSE_FILE_PATTERNS) {
     const filePath = (0, import_path10.join)(cwd, fileName);
     try {
-      await (0, import_promises.access)(filePath, import_fs10.constants.R_OK);
-      const text = await (0, import_promises.readFile)(filePath, "utf-8");
+      await (0, import_promises2.access)(filePath, import_fs10.constants.R_OK);
+      const text = await (0, import_promises2.readFile)(filePath, "utf-8");
       const type2 = detectLicenseType(text);
       const url = generateLicenseUrl(repositoryUrl, fileName);
       return {
@@ -10254,7 +10301,7 @@ function validateLicenseInfo(licenseInfo, packageName) {
 
 // src/utils/snippet-extractor.ts
 init_cjs_shims();
-var import_promises2 = require("fs/promises");
+var import_promises3 = require("fs/promises");
 var import_path11 = require("path");
 var MAX_SNIPPET_LENGTH = 2e3;
 async function extractSnippet(manifest) {
@@ -10272,12 +10319,12 @@ async function extractSnippet(manifest) {
       fileName = typeof firstFile === "string" ? firstFile : firstFile.path;
     }
     const fullPath = (0, import_path11.join)(cwd, fileName);
-    const stats = await (0, import_promises2.stat)(fullPath);
+    const stats = await (0, import_promises3.stat)(fullPath);
     if (stats.isDirectory()) {
       console.warn(`\u26A0\uFE0F  Skipping snippet extraction: "${fullPath}" is a directory`);
       return null;
     }
-    const content = await (0, import_promises2.readFile)(fullPath, "utf-8");
+    const content = await (0, import_promises3.readFile)(fullPath, "utf-8");
     if (content.length <= MAX_SNIPPET_LENGTH) {
       return content.trim();
     }
@@ -10360,7 +10407,7 @@ async function executePrepublishOnly(scripts, options = {}) {
 
 // src/utils/format-file-validator.ts
 init_cjs_shims();
-var import_promises3 = require("fs/promises");
+var import_promises4 = require("fs/promises");
 function normalizeFilePaths(files) {
   return files.map((file) => {
     if (typeof file === "string") {
@@ -10388,7 +10435,7 @@ function getFormatType(format, subtype) {
 async function validateMarkdownFile(filePath, formatType) {
   try {
     const { validateMarkdown: validateMarkdown2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
-    const content = await (0, import_promises3.readFile)(filePath, "utf-8");
+    const content = await (0, import_promises4.readFile)(filePath, "utf-8");
     const result = validateMarkdown2(formatType, content);
     return {
       valid: result.valid,
@@ -10494,7 +10541,7 @@ async function findAndLoadManifests() {
   let prpmJsonExists = false;
   let prpmJsonError = null;
   try {
-    const content = await (0, import_promises4.readFile)(prpmJsonPath, "utf-8");
+    const content = await (0, import_promises5.readFile)(prpmJsonPath, "utf-8");
     prpmJsonExists = true;
     const manifest = JSON.parse(content);
     const collections = [];
@@ -10543,7 +10590,7 @@ async function findAndLoadManifests() {
   }
   const marketplaceJsonPath = (0, import_path12.join)(process.cwd(), ".claude", "marketplace.json");
   try {
-    const content = await (0, import_promises4.readFile)(marketplaceJsonPath, "utf-8");
+    const content = await (0, import_promises5.readFile)(marketplaceJsonPath, "utf-8");
     const marketplaceData = JSON.parse(content);
     if (!validateMarketplaceJson(marketplaceData)) {
       throw new Error("Invalid marketplace.json format");
@@ -10559,7 +10606,7 @@ async function findAndLoadManifests() {
   }
   const marketplaceJsonPluginPath = (0, import_path12.join)(process.cwd(), ".claude-plugin", "marketplace.json");
   try {
-    const content = await (0, import_promises4.readFile)(marketplaceJsonPluginPath, "utf-8");
+    const content = await (0, import_promises5.readFile)(marketplaceJsonPluginPath, "utf-8");
     const marketplaceData = JSON.parse(content);
     if (!validateMarketplaceJson(marketplaceData)) {
       throw new Error("Invalid marketplace.json format");
@@ -10672,7 +10719,7 @@ async function createTarball(manifest) {
   const tmpDir = (0, import_path12.join)((0, import_os3.tmpdir)(), `prpm-${(0, import_crypto2.randomBytes)(8).toString("hex")}`);
   const tarballPath = (0, import_path12.join)(tmpDir, "package.tar.gz");
   try {
-    await (0, import_promises4.mkdir)(tmpDir, { recursive: true });
+    await (0, import_promises5.mkdir)(tmpDir, { recursive: true });
     const filePaths = normalizeFilePaths2(manifest.files);
     const standardFiles = ["prpm.json", "README.md", "LICENSE"];
     for (const file of standardFiles) {
@@ -10683,7 +10730,7 @@ async function createTarball(manifest) {
     const existingFiles = [];
     for (const file of filePaths) {
       try {
-        await (0, import_promises4.stat)(file);
+        await (0, import_promises5.stat)(file);
         existingFiles.push(file);
       } catch {
       }
@@ -10699,7 +10746,7 @@ async function createTarball(manifest) {
       },
       existingFiles
     );
-    const tarballBuffer = await (0, import_promises4.readFile)(tarballPath);
+    const tarballBuffer = await (0, import_promises5.readFile)(tarballPath);
     const sizeMB = tarballBuffer.length / (1024 * 1024);
     if (sizeMB > 10) {
       throw new Error(`Package size (${sizeMB.toFixed(2)}MB) exceeds 10MB limit`);
@@ -10709,7 +10756,7 @@ async function createTarball(manifest) {
     throw error;
   } finally {
     try {
-      await (0, import_promises4.rm)(tmpDir, { recursive: true, force: true });
+      await (0, import_promises5.rm)(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -10732,7 +10779,7 @@ async function handlePublish(options) {
     if (source === "prpm.json (multi-package)" || source === "prpm.json") {
       try {
         const prpmJsonPath = (0, import_path12.join)(process.cwd(), "prpm.json");
-        const prpmContent = await (0, import_promises4.readFile)(prpmJsonPath, "utf-8");
+        const prpmContent = await (0, import_promises5.readFile)(prpmJsonPath, "utf-8");
         const prpmManifest = JSON.parse(prpmContent);
         if (prpmManifest.scripts) {
           await executePrepublishOnly(prpmManifest.scripts);
@@ -11722,7 +11769,7 @@ function createSchemaCommand() {
 // src/commands/init.ts
 init_cjs_shims();
 var import_commander18 = require("commander");
-var import_promises5 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 var import_path13 = require("path");
 var import_fs11 = require("fs");
 var readline3 = __toESM(require("readline/promises"));
@@ -12029,7 +12076,7 @@ ${question}`);
 }
 async function extractMetadataFromFile(filePath) {
   try {
-    const content = await (0, import_promises5.readFile)(filePath, "utf-8");
+    const content = await (0, import_promises6.readFile)(filePath, "utf-8");
     const metadata = {};
     const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
     if (frontmatterMatch) {
@@ -12094,7 +12141,7 @@ async function createExampleFiles(format, files, packageName) {
     const filePath = (0, import_path13.join)(process.cwd(), file);
     const dirPath = (0, import_path13.join)(filePath, "..");
     if (!(0, import_fs11.existsSync)(dirPath)) {
-      await (0, import_promises5.mkdir)(dirPath, { recursive: true });
+      await (0, import_promises6.mkdir)(dirPath, { recursive: true });
     }
     if ((0, import_fs11.existsSync)(filePath)) {
       console.log(`  Skipping ${file} (already exists)`);
@@ -12105,7 +12152,7 @@ async function createExampleFiles(format, files, packageName) {
 Add your content here.
 `;
     content = content.replace(/example-skill/g, packageName);
-    await (0, import_promises5.writeFile)(filePath, content, "utf-8");
+    await (0, import_promises6.writeFile)(filePath, content, "utf-8");
     console.log(`  Created ${file}`);
   }
 }
@@ -12141,7 +12188,7 @@ ${config.author}
 
 ${config.license}
 `;
-  await (0, import_promises5.writeFile)(readmePath, content, "utf-8");
+  await (0, import_promises6.writeFile)(readmePath, content, "utf-8");
   console.log("  Created README.md");
 }
 async function initPackage(options) {
@@ -12298,7 +12345,7 @@ Current files (${config.files.length}):`);
     manifest.tags = config.tags;
   }
   manifest.files = config.files;
-  await (0, import_promises5.writeFile)(
+  await (0, import_promises6.writeFile)(
     manifestPath,
     JSON.stringify(manifest, null, 2) + "\n",
     "utf-8"
@@ -12444,7 +12491,7 @@ function createConfigCommand() {
 // src/commands/catalog.ts
 init_cjs_shims();
 var import_commander20 = require("commander");
-var import_promises6 = require("fs/promises");
+var import_promises7 = require("fs/promises");
 var import_path14 = require("path");
 init_telemetry();
 init_lockfile();
@@ -12503,7 +12550,7 @@ async function scanDirectory2(dirPath, baseDir, scanDir, maxDepth = 5, currentDe
   }
   const discovered = [];
   try {
-    const entries = await (0, import_promises6.readdir)(dirPath, { withFileTypes: true });
+    const entries = await (0, import_promises7.readdir)(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = (0, import_path14.join)(dirPath, entry.name);
       const relativePath = (0, import_path14.relative)(baseDir, fullPath);
@@ -12515,7 +12562,7 @@ async function scanDirectory2(dirPath, baseDir, scanDir, maxDepth = 5, currentDe
         discovered.push(...subDirPackages);
       } else if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdc") || entry.name.endsWith(".txt"))) {
         try {
-          const content = await (0, import_promises6.readFile)(fullPath, "utf-8");
+          const content = await (0, import_promises7.readFile)(fullPath, "utf-8");
           const packageInfo = detectPackageInfo(fullPath, content);
           if (packageInfo) {
             discovered.push({
@@ -12594,7 +12641,7 @@ async function handleCatalog(directories, options) {
     for (const dir of directories) {
       console.log(`   Scanning ${dir}...`);
       try {
-        const dirStat = await (0, import_promises6.stat)(dir);
+        const dirStat = await (0, import_promises7.stat)(dir);
         if (!dirStat.isDirectory()) {
           console.log(`   \u26A0\uFE0F  Skipping ${dir} (not a directory)`);
           continue;
@@ -12647,7 +12694,7 @@ async function handleCatalog(directories, options) {
     let manifest;
     if (options.append) {
       try {
-        const existingContent = await (0, import_promises6.readFile)(prpmJsonPath, "utf-8");
+        const existingContent = await (0, import_promises7.readFile)(prpmJsonPath, "utf-8");
         const existing = JSON.parse(existingContent);
         if ("packages" in existing && Array.isArray(existing.packages)) {
           manifest = existing;
@@ -12682,7 +12729,7 @@ async function handleCatalog(directories, options) {
       let description = `${discovered.format} ${discovered.subtype}`;
       try {
         const firstFilePath = (0, import_path14.join)(process.cwd(), discovered.scanDir, discovered.files[0]);
-        const content = await (0, import_promises6.readFile)(firstFilePath, "utf-8");
+        const content = await (0, import_promises7.readFile)(firstFilePath, "utf-8");
         const extractedDesc = extractDescription2(content);
         if (extractedDesc) {
           description = extractedDesc;
@@ -12702,7 +12749,7 @@ async function handleCatalog(directories, options) {
       manifest.packages.push(packageManifest);
       addedCount++;
     }
-    await (0, import_promises6.writeFile)(prpmJsonPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+    await (0, import_promises7.writeFile)(prpmJsonPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
     console.log(`
 \u2705 Updated ${prpmJsonPath}`);
     console.log(`   Added ${addedCount} new package(s)`);
@@ -13931,7 +13978,7 @@ function createStarredCommand() {
 // src/commands/convert.ts
 init_cjs_shims();
 var import_commander26 = require("commander");
-var import_promises7 = require("fs/promises");
+var import_promises8 = require("fs/promises");
 var import_path15 = require("path");
 var import_fs12 = require("fs");
 var import_readline = require("readline");
@@ -14037,7 +14084,7 @@ async function handleConvert(sourcePath, options) {
     console.log(import_chalk.default.dim("Reading source file..."));
     let content;
     try {
-      content = await (0, import_promises7.readFile)(sourcePath, "utf-8");
+      content = await (0, import_promises8.readFile)(sourcePath, "utf-8");
     } catch (error) {
       throw new CLIError(`Failed to read source file: ${error.message}`);
     }
@@ -14137,9 +14184,9 @@ async function handleConvert(sourcePath, options) {
       }
     }
     const outputDir = (0, import_path15.dirname)(outputPath);
-    await (0, import_promises7.mkdir)(outputDir, { recursive: true });
+    await (0, import_promises8.mkdir)(outputDir, { recursive: true });
     console.log(import_chalk.default.dim("Writing converted file..."));
-    await (0, import_promises7.writeFile)(outputPath, result.content, "utf-8");
+    await (0, import_promises8.writeFile)(outputPath, result.content, "utf-8");
     console.log(import_chalk.default.green(`\u2713 Converted file written to ${outputPath}`));
     console.log();
     if (options.to === "cursor") {

package/dist/schemas/prpm-manifest.schema.json

@@ -0,0 +1,723 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://prpm.dev/schemas/manifest.json",
+  "title": "PRPM Package Manifest",
+  "description": "Schema for PRPM package manifest (prpm.json)",
+  "type": "object",
+  "required": [
+    "name",
+    "version",
+    "description",
+    "format"
+  ],
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Package name in format: package-name or @scope/package-name",
+      "pattern": "^(@[a-z0-9-]+\\/)?[a-z0-9-]+$",
+      "minLength": 1,
+      "maxLength": 214,
+      "examples": [
+        "react-rules",
+        "@community/testing-skills",
+        "@company/cursor-rules"
+      ]
+    },
+    "version": {
+      "type": "string",
+      "description": "Semantic version (semver)",
+      "pattern": "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$",
+      "examples": [
+        "1.0.0",
+        "2.1.3",
+        "1.0.0-beta.1"
+      ]
+    },
+    "description": {
+      "type": "string",
+      "description": "Package description",
+      "minLength": 10,
+      "maxLength": 500
+    },
+    "format": {
+      "type": "string",
+      "description": "Package format - the AI tool/platform this package is for",
+      "enum": [
+        "cursor",
+        "claude",
+        "continue",
+        "windsurf",
+        "copilot",
+        "kiro",
+        "agents.md",
+        "generic",
+        "mcp"
+      ]
+    },
+    "subtype": {
+      "type": "string",
+      "description": "Package subtype - the functional category (optional, defaults to 'rule')",
+      "enum": [
+        "rule",
+        "agent",
+        "skill",
+        "slash-command",
+        "prompt",
+        "workflow",
+        "tool",
+        "template",
+        "collection"
+      ]
+    },
+    "author": {
+      "description": "Package author",
+      "oneOf": [
+        {
+          "type": "string",
+          "examples": [
+            "John Doe",
+            "Jane Smith"
+          ]
+        },
+        {
+          "type": "object",
+          "required": [
+            "name"
+          ],
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "Author name"
+            },
+            "email": {
+              "type": "string",
+              "format": "email",
+              "description": "Author email"
+            },
+            "url": {
+              "type": "string",
+              "format": "uri",
+              "description": "Author URL"
+            }
+          }
+        }
+      ]
+    },
+    "license": {
+      "type": "string",
+      "description": "SPDX license identifier",
+      "examples": [
+        "MIT",
+        "Apache-2.0",
+        "GPL-3.0",
+        "BSD-3-Clause"
+      ]
+    },
+    "license_text": {
+      "type": "string",
+      "description": "Full text of the license file for proper attribution"
+    },
+    "license_url": {
+      "type": "string",
+      "format": "uri",
+      "description": "URL to the license file in the repository"
+    },
+    "repository": {
+      "type": "string",
+      "format": "uri",
+      "description": "Repository URL",
+      "examples": [
+        "https://github.com/username/repo"
+      ]
+    },
+    "homepage": {
+      "type": "string",
+      "format": "uri",
+      "description": "Package homepage URL"
+    },
+    "documentation": {
+      "type": "string",
+      "format": "uri",
+      "description": "Documentation URL"
+    },
+    "organization": {
+      "type": "string",
+      "description": "Organization name or ID to publish this package under. If not specified, publishes to personal account.",
+      "examples": [
+        "my-team",
+        "my-company"
+      ]
+    },
+    "private": {
+      "type": "boolean",
+      "description": "Whether the package is private. Private packages are only accessible to the owner/organization members. Defaults to false (public).",
+      "default": false
+    },
+    "scripts": {
+      "type": "object",
+      "description": "Lifecycle scripts that run during package operations. Only applies to multi-package manifests (prpm.json with packages array).",
+      "properties": {
+        "prepublishOnly": {
+          "type": "string",
+          "description": "Script to run before publishing (recommended - only runs on 'prpm publish')",
+          "examples": [
+            "npm run build",
+            "cd packages/hooks && npm run build",
+            "npm test && npm run build"
+          ]
+        },
+        "prepublish": {
+          "type": "string",
+          "description": "Script to run before publishing and on npm install (not recommended - use prepublishOnly instead)",
+          "examples": [
+            "npm run build"
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "tags": {
+      "type": "array",
+      "description": "Package tags for categorization",
+      "items": {
+        "type": "string"
+      },
+      "maxItems": 10,
+      "uniqueItems": true,
+      "examples": [
+        [
+          "productivity",
+          "coding"
+        ],
+        [
+          "testing",
+          "quality"
+        ]
+      ]
+    },
+    "keywords": {
+      "type": "array",
+      "description": "Search keywords",
+      "items": {
+        "type": "string"
+      },
+      "maxItems": 20,
+      "uniqueItems": true,
+      "examples": [
+        [
+          "ai",
+          "prompts",
+          "development"
+        ]
+      ]
+    },
+    "category": {
+      "type": "string",
+      "description": "Package category",
+      "examples": [
+        "development",
+        "productivity",
+        "testing"
+      ]
+    },
+    "files": {
+      "description": "Files to include in package. Can be simple paths or enhanced file objects with metadata.",
+      "oneOf": [
+        {
+          "type": "array",
+          "description": "Simple format: array of file paths",
+          "items": {
+            "type": "string"
+          },
+          "minItems": 1,
+          "examples": [
+            [
+              "skill.md",
+              "README.md"
+            ],
+            [
+              ".cursor/rules/react.mdc",
+              "LICENSE"
+            ]
+          ]
+        },
+        {
+          "type": "array",
+          "description": "Enhanced format: array of file objects with metadata",
+          "items": {
+            "type": "object",
+            "required": [
+              "path",
+              "format"
+            ],
+            "properties": {
+              "path": {
+                "type": "string",
+                "description": "Relative path to file",
+                "examples": [
+                  ".claude/skills/tdd.md",
+                  ".cursor/rules/react.mdc",
+                  ".continue/rules/python.json"
+                ]
+              },
+              "format": {
+                "type": "string",
+                "description": "File format - the AI tool/platform this file is for",
+                "enum": [
+                  "cursor",
+                  "claude",
+                  "continue",
+                  "windsurf",
+                  "copilot",
+                  "kiro",
+                  "agents.md",
+                  "generic",
+                  "mcp"
+                ]
+              },
+              "subtype": {
+                "type": "string",
+                "description": "File subtype - the functional category",
+                "enum": [
+                  "rule",
+                  "agent",
+                  "skill",
+                  "slash-command",
+                  "prompt",
+                  "workflow",
+                  "tool",
+                  "template",
+                  "collection"
+                ]
+              },
+              "name": {
+                "type": "string",
+                "description": "Display name for this file",
+                "examples": [
+                  "React Rules",
+                  "Test-Driven Development"
+                ]
+              },
+              "description": {
+                "type": "string",
+                "description": "Description of what this file does"
+              },
+              "tags": {
+                "type": "array",
+                "description": "File-specific tags",
+                "items": {
+                  "type": "string"
+                },
+                "uniqueItems": true,
+                "examples": [
+                  [
+                    "react",
+                    "typescript"
+                  ],
+                  [
+                    "testing",
+                    "tdd"
+                  ]
+                ]
+              }
+            },
+            "additionalProperties": false
+          },
+          "minItems": 1
+        }
+      ]
+    },
+    "main": {
+      "type": "string",
+      "description": "Main entry file (for single-file packages)",
+      "examples": [
+        "index.md",
+        "skill.md"
+      ]
+    },
+    "dependencies": {
+      "type": "object",
+      "description": "Package dependencies",
+      "patternProperties": {
+        "^(@[a-z0-9-]+\\/)?[a-z0-9-]+$": {
+          "type": "string",
+          "pattern": "^(\\^|~)?\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$"
+        }
+      },
+      "additionalProperties": false,
+      "examples": [
+        {
+          "@pr-pm/utils": "^1.0.0",
+          "common-rules": "~2.1.0"
+        }
+      ]
+    },
+    "peerDependencies": {
+      "type": "object",
+      "description": "Peer dependencies (packages that should be installed alongside)",
+      "patternProperties": {
+        "^(@[a-z0-9-]+\\/)?[a-z0-9-]+$": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false
+    },
+    "engines": {
+      "type": "object",
+      "description": "Required engine versions",
+      "properties": {
+        "prpm": {
+          "type": "string",
+          "description": "Required PRPM version"
+        },
+        "node": {
+          "type": "string",
+          "description": "Required Node.js version"
+        }
+      },
+      "additionalProperties": false,
+      "examples": [
+        {
+          "prpm": ">=1.0.0",
+          "node": ">=18.0.0"
+        }
+      ]
+    },
+    "packages": {
+      "type": "array",
+      "description": "Array of packages to publish from a single manifest (multi-package publishing). Packages inherit top-level fields unless overridden.",
+      "items": {
+        "$ref": "#"
+      },
+      "minItems": 1
+    },
+    "collections": {
+      "type": "array",
+      "description": "Array of collections to publish. Collections bundle multiple packages together for easier installation.",
+      "items": {
+        "type": "object",
+        "required": ["id", "name", "description", "packages"],
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Unique collection identifier (kebab-case)",
+            "pattern": "^[a-z0-9-]+$",
+            "minLength": 3,
+            "maxLength": 100,
+            "examples": ["nextjs-complete", "fullstack-setup", "react-essentials"]
+          },
+          "name": {
+            "type": "string",
+            "description": "Display name of the collection",
+            "minLength": 3,
+            "maxLength": 100,
+            "examples": ["Next.js Complete", "Full Stack Setup"]
+          },
+          "description": {
+            "type": "string",
+            "description": "What this collection provides",
+            "minLength": 10,
+            "maxLength": 500
+          },
+          "version": {
+            "type": "string",
+            "description": "Semantic version of the collection",
+            "pattern": "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$",
+            "examples": ["1.0.0", "2.1.0"]
+          },
+          "category": {
+            "type": "string",
+            "description": "Collection category",
+            "enum": ["development", "testing", "deployment", "data-science", "devops", "design", "documentation", "security", "performance", "general"],
+            "examples": ["development", "testing"]
+          },
+          "tags": {
+            "type": "array",
+            "description": "Tags for discoverability (kebab-case)",
+            "items": {
+              "type": "string",
+              "pattern": "^[a-z0-9-]+$"
+            },
+            "minItems": 1,
+            "maxItems": 10,
+            "examples": [["react", "typescript", "nextjs"], ["python", "data-science", "ml"]]
+          },
+          "icon": {
+            "type": "string",
+            "description": "Emoji or icon for the collection",
+            "maxLength": 10,
+            "examples": ["⚛️", "🚀", "📦"]
+          },
+          "packages": {
+            "type": "array",
+            "description": "Array of packages included in this collection",
+            "items": {
+              "type": "object",
+              "required": ["packageId"],
+              "properties": {
+                "packageId": {
+                  "type": "string",
+                  "description": "Package identifier to include",
+                  "minLength": 1,
+                  "examples": ["typescript-strict", "react-best-practices"]
+                },
+                "version": {
+                  "type": "string",
+                  "description": "Version range (semver) or 'latest'",
+                  "examples": ["^1.0.0", "~2.1.0", "1.0.0", "latest"]
+                },
+                "required": {
+                  "type": "boolean",
+                  "description": "Whether this package is required (true) or optional (false)",
+                  "default": true
+                },
+                "reason": {
+                  "type": "string",
+                  "description": "Explanation of why this package is included",
+                  "maxLength": 200,
+                  "examples": ["Enforces strict TypeScript type safety", "React component best practices"]
+                }
+              }
+            },
+            "minItems": 1
+          }
+        }
+      },
+      "minItems": 1
+    }
+  },
+  "additionalProperties": false,
+  "examples": [
+    {
+      "name": "@username/simple-package",
+      "version": "1.0.0",
+      "description": "A simple package with basic files",
+      "format": "claude", "subtype": "skill",
+      "author": "Your Name",
+      "license": "MIT",
+      "files": [
+        "skill.md",
+        "README.md"
+      ]
+    },
+    {
+      "name": "@company/team-package",
+      "version": "1.0.0",
+      "description": "A package published under organization account",
+      "format": "cursor",
+      "author": "Team Name",
+      "organization": "my-company",
+      "license": "MIT",
+      "files": [
+        ".cursor/rules/guidelines.mdc",
+        "README.md"
+      ]
+    },
+    {
+      "name": "@username/cursor-rules",
+      "version": "1.0.0",
+      "description": "Multiple Cursor rules for different languages",
+      "format": "cursor",
+      "author": {
+        "name": "Your Name",
+        "email": "you@example.com"
+      },
+      "license": "MIT",
+      "repository": "https://github.com/username/cursor-rules",
+      "tags": [
+        "cursor",
+        "rules",
+        "multi-language"
+      ],
+      "files": [
+        {
+          "path": ".cursor/rules/typescript.mdc",
+          "format": "cursor",
+          "name": "TypeScript Rules",
+          "tags": [
+            "typescript",
+            "frontend"
+          ]
+        },
+        {
+          "path": ".cursor/rules/python.mdc",
+          "format": "cursor",
+          "name": "Python Rules",
+          "tags": [
+            "python",
+            "backend"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "@community/testing-suite",
+      "version": "2.0.0",
+      "description": "Complete testing suite with skills and agents",
+      "format": "generic", "subtype": "collection",
+      "author": "Community",
+      "license": "MIT",
+      "tags": [
+        "testing",
+        "quality"
+      ],
+      "files": [
+        {
+          "path": ".claude/skills/tdd.md",
+          "format": "claude", "subtype": "skill",
+          "name": "Test-Driven Development"
+        },
+        {
+          "path": ".claude/agents/test-generator.md",
+          "format": "claude", "subtype": "agent",
+          "name": "Test Generator"
+        }
+      ]
+    },
+    {
+      "name": "@username/copilot-instructions",
+      "version": "1.0.0",
+      "description": "GitHub Copilot instructions for API development",
+      "format": "copilot",
+      "author": "Your Name",
+      "license": "MIT",
+      "tags": [
+        "copilot",
+        "api",
+        "backend"
+      ],
+      "files": [
+        "api-guidelines.md"
+      ]
+    },
+    {
+      "name": "@username/kiro-steering",
+      "version": "1.0.0",
+      "description": "Kiro steering file for testing standards",
+      "format": "kiro",
+      "author": "Your Name",
+      "license": "MIT",
+      "tags": [
+        "kiro",
+        "testing",
+        "quality"
+      ],
+      "files": [
+        "testing.md"
+      ]
+    },
+    {
+      "name": "@username/windsurf-rules",
+      "version": "1.0.0",
+      "description": "Windsurf coding rules for React projects",
+      "format": "windsurf",
+      "author": "Your Name",
+      "license": "MIT",
+      "tags": [
+        "windsurf",
+        "react",
+        "frontend"
+      ],
+      "files": [
+        ".windsurfrules"
+      ]
+    },
+    {
+      "name": "@company/private-package",
+      "version": "1.0.0",
+      "description": "A private package only accessible to organization members",
+      "format": "claude",
+      "subtype": "skill",
+      "author": "Company Team",
+      "organization": "my-company",
+      "private": true,
+      "license": "Proprietary",
+      "files": [
+        "internal-skill.md",
+        "README.md"
+      ]
+    },
+    {
+      "name": "@username/multi-package-example",
+      "version": "1.0.0",
+      "description": "Multi-package manifest example",
+      "author": "Your Name",
+      "license": "MIT",
+      "repository": "https://github.com/username/multi-package",
+      "packages": [
+        {
+          "name": "@username/package-one",
+          "version": "1.0.0",
+          "description": "First package in the multi-package manifest",
+          "format": "claude",
+          "subtype": "skill",
+          "files": [
+            "package-one/SKILL.md"
+          ]
+        },
+        {
+          "name": "@username/package-two",
+          "version": "1.0.0",
+          "description": "Second package with different settings",
+          "format": "cursor",
+          "private": true,
+          "files": [
+            "package-two/.cursor/rules/main.mdc"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "@username/multi-package-with-collection",
+      "version": "1.0.0",
+      "description": "Repository with both packages and a collection",
+      "author": "Your Name",
+      "license": "MIT",
+      "packages": [
+        {
+          "name": "typescript-rules",
+          "version": "1.0.0",
+          "description": "TypeScript coding standards",
+          "format": "cursor",
+          "subtype": "rule",
+          "tags": ["typescript", "cursor"],
+          "files": [".cursor/rules/typescript.mdc"]
+        },
+        {
+          "name": "react-patterns",
+          "version": "1.0.0",
+          "description": "React best practices",
+          "format": "claude",
+          "subtype": "skill",
+          "tags": ["react", "best-practices"],
+          "files": [".claude/skills/react-patterns/SKILL.md"]
+        }
+      ],
+      "collections": [
+        {
+          "id": "fullstack-setup",
+          "name": "Full Stack Setup",
+          "description": "Complete full-stack development setup with TypeScript and React",
+          "version": "1.0.0",
+          "category": "development",
+          "tags": ["typescript", "react", "fullstack"],
+          "icon": "🚀",
+          "packages": [
+            {
+              "packageId": "typescript-rules",
+              "version": "^1.0.0",
+              "required": true,
+              "reason": "TypeScript coding standards for the project"
+            },
+            {
+              "packageId": "react-patterns",
+              "version": "^1.0.0",
+              "required": true,
+              "reason": "React component best practices"
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prpm",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Prompt Package Manager CLI - Install and manage prompt-based files",
   "main": "dist/index.js",
   "bin": {
@@ -45,9 +45,9 @@
   "license": "MIT",
   "dependencies": {
     "@octokit/rest": "^22.0.0",
-    "@pr-pm/converters": "^0.1.0",
-    "@pr-pm/registry-client": "^1.4.0",
-    "@pr-pm/types": "^0.3.0",
+    "@pr-pm/converters": "^1.0.2",
+    "@pr-pm/registry-client": "^2.0.2",
+    "@pr-pm/types": "^1.0.2",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "commander": "^11.1.0",