prpm 0.0.21 → 0.1.1

package/dist/commands/list.js

@@ -32,6 +32,8 @@ function getDestinationDir(type) {
             return '.continue/rules';
         case 'windsurf':
             return '.windsurf/rules';
+        case 'agents.md':
+            return '.agents';
         case 'generic':
             return '.prompts';
         case 'mcp':

package/dist/commands/popular.js

@@ -25,7 +25,7 @@ async function handlePopular(options) {
 function createPopularCommand() {
     return new commander_1.Command('popular')
         .description('Show popular packages (all time)')
-        .option('--format <format>', 'Filter by format (cursor, claude, continue, windsurf, copilot, kiro, generic)')
+        .option('--format <format>', 'Filter by format (cursor, claude, continue, windsurf, copilot, kiro, agents.md, generic)')
         .option('--subtype <subtype>', 'Filter by subtype (rule, agent, skill, slash-command, prompt, workflow, tool, template, collection)')
         .action(async (options) => {
         await handlePopular(options);

package/dist/commands/publish.js

@@ -54,7 +54,7 @@ const snippet_extractor_1 = require("../utils/snippet-extractor");
 /**
  * Try to find and load manifest files
  * Checks for:
- * 1. prpm.json (native format) - returns single manifest or array of packages
+ * 1. prpm.json (native format) - returns single manifest or array of packages and collections
  * 2. .claude/marketplace.json (Claude format) - returns all plugins as separate manifests
  * 3. .claude-plugin/marketplace.json (Claude format - alternative location) - returns all plugins
  */
@@ -66,6 +66,12 @@ async function findAndLoadManifests() {
     try {
         const content = await (0, promises_1.readFile)(prpmJsonPath, 'utf-8');
         const manifest = JSON.parse(content);
+        // Extract collections if present
+        const collections = [];
+        if ('collections' in manifest && Array.isArray(manifest.collections)) {
+            const rawCollections = manifest.collections;
+            collections.push(...rawCollections);
+        }
         // Check if this is a multi-package manifest
         if ('packages' in manifest && Array.isArray(manifest.packages)) {
             const multiManifest = manifest;
@@ -94,11 +100,15 @@ async function findAndLoadManifests() {
                 };
                 return validateManifest(packageWithDefaults);
             });
-            return { manifests: validatedManifests, source: 'prpm.json (multi-package)' };
+            return { manifests: validatedManifests, collections, source: 'prpm.json (multi-package)' };
+        }
+        // Collections-only manifest (no packages)
+        if (collections.length > 0) {
+            return { manifests: [], collections, source: 'prpm.json (collections-only)' };
         }
         // Single package manifest
         const validated = validateManifest(manifest);
-        return { manifests: [validated], source: 'prpm.json' };
+        return { manifests: [validated], collections, source: 'prpm.json' };
     }
     catch (error) {
         // Store error for later
@@ -127,7 +137,7 @@ async function findAndLoadManifests() {
             const validated = validateManifest(manifest);
             manifests.push(validated);
         }
-        return { manifests, source: '.claude/marketplace.json' };
+        return { manifests, collections: [], source: '.claude/marketplace.json' };
     }
     catch (error) {
         // marketplace.json not found or invalid at .claude path, try .claude-plugin
@@ -147,7 +157,7 @@ async function findAndLoadManifests() {
             const validated = validateManifest(manifest);
             manifests.push(validated);
         }
-        return { manifests, source: '.claude-plugin/marketplace.json' };
+        return { manifests, collections: [], source: '.claude-plugin/marketplace.json' };
     }
     catch (error) {
         // marketplace.json not found or invalid
@@ -322,13 +332,21 @@ async function handlePublish(options) {
         console.log('📦 Publishing package...\n');
         // Read and validate manifests
         console.log('🔍 Validating package manifest(s)...');
-        const { manifests, source } = await findAndLoadManifests();
-        if (manifests.length > 1) {
-            console.log(`   Found ${manifests.length} plugins in ${source}`);
-            if (options.package) {
-                console.log(`   Filtering to package: ${options.package}`);
+        const { manifests, collections, source } = await findAndLoadManifests();
+        if (manifests.length > 1 || collections.length > 0) {
+            if (manifests.length > 0) {
+                console.log(`   Found ${manifests.length} package(s) in ${source}`);
+                if (options.package) {
+                    console.log(`   Filtering to package: ${options.package}`);
+                }
             }
-            console.log('   Will publish each plugin separately\n');
+            if (collections.length > 0) {
+                console.log(`   Found ${collections.length} collection(s) in ${source}`);
+                if (options.collection) {
+                    console.log(`   Filtering to collection: ${options.collection}`);
+                }
+            }
+            console.log('   Will publish each separately\n');
         }
         // Filter to specific package if requested
         let filteredManifests = manifests;
@@ -373,9 +391,11 @@ async function handlePublish(options) {
                 throw new Error('Cannot publish packages with duplicate names');
             }
         }
-        // Track published packages
+        // Track published packages and collections
         const publishedPackages = [];
         const failedPackages = [];
+        const publishedCollections = [];
+        const failedCollections = [];
         // Publish each manifest (filtered set)
         for (let i = 0; i < filteredManifests.length; i++) {
             const manifest = filteredManifests[i];
@@ -538,6 +558,94 @@ async function handlePublish(options) {
                 });
             }
         }
+        // Publish collections if present
+        if (collections.length > 0) {
+            // Filter to specific collection if requested
+            let filteredCollections = collections;
+            if (options.collection) {
+                filteredCollections = collections.filter(c => c.id === options.collection);
+                if (filteredCollections.length === 0) {
+                    throw new Error(`Collection "${options.collection}" not found in manifest. Available collections: ${collections.map(c => c.id).join(', ')}`);
+                }
+                console.log(`   ✓ Found collection "${options.collection}"\n`);
+            }
+            for (const collection of filteredCollections) {
+                if (filteredCollections.length > 1) {
+                    console.log(`\n${'='.repeat(60)}`);
+                    console.log(`📚 Publishing collection`);
+                    console.log(`${'='.repeat(60)}\n`);
+                }
+                try {
+                    console.log(`📚 Publishing collection "${collection.name}"...`);
+                    console.log(`   ID: ${collection.id}`);
+                    console.log(`   Packages: ${collection.packages.length}`);
+                    console.log('');
+                    if (options.dryRun) {
+                        console.log('✅ Dry run successful! Collection is ready to publish.');
+                        publishedCollections.push({
+                            id: collection.id,
+                            name: collection.name,
+                            version: collection.version || '1.0.0'
+                        });
+                        continue;
+                    }
+                    // Import and call the collection publish logic
+                    const { handleCollectionPublish } = await Promise.resolve().then(() => __importStar(require('./collections.js')));
+                    // Create a temporary manifest object for the collection
+                    const collectionData = {
+                        id: collection.id,
+                        name: collection.name,
+                        description: collection.description,
+                        version: collection.version,
+                        category: collection.category,
+                        tags: collection.tags,
+                        icon: collection.icon,
+                        packages: collection.packages.map(pkg => ({
+                            packageId: pkg.packageId,
+                            version: pkg.version,
+                            required: pkg.required !== false,
+                            reason: pkg.reason,
+                        })),
+                    };
+                    const result = await client.createCollection(collectionData);
+                    console.log(`✅ Collection published successfully!`);
+                    console.log(`   Scope: ${result.scope}`);
+                    console.log(`   Name: ${result.name_slug}`);
+                    console.log(`   Version: ${result.version || '1.0.0'}`);
+                    console.log('');
+                    console.log(`💡 Install: prpm install collections/${result.name_slug}`);
+                    console.log('');
+                    publishedCollections.push({
+                        id: collection.id,
+                        name: collection.name,
+                        version: result.version || '1.0.0'
+                    });
+                }
+                catch (err) {
+                    const collError = err instanceof Error ? err.message : String(err);
+                    console.error(`\n❌ Failed to publish collection ${collection.id}: ${collError}\n`);
+                    failedCollections.push({
+                        id: collection.id,
+                        error: collError
+                    });
+                }
+            }
+            // Add collection results to summary
+            if (publishedCollections.length > 0) {
+                console.log(`✅ Successfully published ${publishedCollections.length} collection(s):`);
+                publishedCollections.forEach(coll => {
+                    console.log(`   - ${coll.name} (${coll.id}) v${coll.version}`);
+                });
+                console.log('');
+            }
+            if (failedCollections.length > 0) {
+                console.log(`❌ Failed to publish ${failedCollections.length} collection(s):`);
+                failedCollections.forEach(coll => {
+                    console.log(`   - ${coll.id}: ${coll.error}`);
+                });
+                console.log('');
+            }
+        }
         // Print summary if multiple packages
         if (manifests.length > 1) {
             console.log(`\n${'='.repeat(60)}`);
@@ -569,8 +677,9 @@ async function handlePublish(options) {
                 }
             }
         }
-        success = publishedPackages.length > 0;
-        if (failedPackages.length > 0 && publishedPackages.length === 0) {
+        // Success if we published any packages OR collections
+        success = publishedPackages.length > 0 || publishedCollections.length > 0;
+        if (failedPackages.length > 0 && publishedPackages.length === 0 && publishedCollections.length === 0) {
             process.exit(1);
         }
     }
@@ -628,11 +737,12 @@ async function handlePublish(options) {
  */
 function createPublishCommand() {
     return new commander_1.Command('publish')
-        .description('Publish a package to the registry')
+        .description('Publish packages and collections to the registry')
         .option('--access <type>', 'Package access (public or private) - overrides manifest setting')
         .option('--tag <tag>', 'NPM-style tag (e.g., latest, beta)', 'latest')
         .option('--dry-run', 'Validate package without publishing')
         .option('--package <name>', 'Publish only a specific package from multi-package manifest')
+        .option('--collection <id>', 'Publish only a specific collection from manifest')
         .action(async (options) => {
         await handlePublish(options);
         process.exit(0);

package/dist/commands/search.js

@@ -391,7 +391,7 @@ function createSearchCommand() {
     command
         .description('Search for packages in the registry')
         .argument('[query]', 'Search query (optional when using --format/--subtype or --author)')
-        .option('--format <format>', 'Filter by package format (cursor, claude, continue, windsurf, copilot, kiro, generic, mcp)')
+        .option('--format <format>', 'Filter by package format (cursor, claude, continue, windsurf, copilot, kiro, agents.md, generic, mcp)')
         .option('--subtype <subtype>', 'Filter by package subtype (rule, agent, skill, slash-command, prompt, workflow, tool, template, collection)')
         .option('--author <username>', 'Filter by author username')
         .option('--limit <number>', 'Number of results per page', '20')
@@ -404,7 +404,7 @@ function createSearchCommand() {
         const author = options.author;
         const limit = options.limit ? parseInt(options.limit, 10) : 20;
         const page = options.page ? parseInt(options.page, 10) : 1;
-        const validFormats = ['cursor', 'claude', 'continue', 'windsurf', 'copilot', 'kiro', 'generic', 'mcp'];
+        const validFormats = ['cursor', 'claude', 'continue', 'windsurf', 'copilot', 'kiro', 'agents.md', 'generic', 'mcp'];
         const validSubtypes = ['rule', 'agent', 'skill', 'slash-command', 'prompt', 'collection', 'chatmode'];
         if (options.format && !validFormats.includes(format)) {
             console.error(`❌ Format must be one of: ${validFormats.join(', ')}`);

package/dist/commands/trending.js

@@ -62,14 +62,14 @@ function createTrendingCommand() {
     const command = new commander_1.Command('trending');
     command
         .description('Show trending packages')
-        .option('--format <format>', 'Filter by format (cursor, claude, continue, windsurf, copilot, kiro, generic)')
+        .option('--format <format>', 'Filter by format (cursor, claude, continue, windsurf, copilot, kiro, agents.md, generic)')
         .option('--subtype <subtype>', 'Filter by subtype (rule, agent, skill, slash-command, prompt, workflow, tool, template, collection)')
         .option('--limit <number>', 'Number of packages to show', '10')
         .action(async (options) => {
         const format = options.format;
         const subtype = options.subtype;
         const limit = options.limit ? parseInt(options.limit, 10) : 10;
-        const validFormats = ['cursor', 'claude', 'continue', 'windsurf', 'copilot', 'kiro', 'generic', 'mcp'];
+        const validFormats = ['cursor', 'claude', 'continue', 'windsurf', 'copilot', 'kiro', 'agents.md', 'generic', 'mcp'];
         const validSubtypes = ['rule', 'agent', 'skill', 'slash-command', 'prompt', 'workflow', 'tool', 'template', 'collection'];
         if (options.format && !validFormats.includes(format)) {
             console.error(`❌ Format must be one of: ${validFormats.join(', ')}`);

package/dist/core/filesystem.js

@@ -52,6 +52,8 @@ function getDestinationDir(format, subtype, name) {
             return '.github/instructions';
         case 'kiro':
             return '.kiro/steering';
+        case 'agents.md':
+            return '.agents';
         case 'generic':
             return '.prompts';
         case 'mcp':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prpm",
-  "version": "0.0.21",
+  "version": "0.1.1",
   "description": "Prompt Package Manager CLI - Install and manage prompt-based files",
   "main": "dist/index.js",
   "bin": {
@@ -45,8 +45,8 @@
   "license": "MIT",
   "dependencies": {
     "@octokit/rest": "^22.0.0",
-    "@pr-pm/registry-client": "^1.2.15",
-    "@pr-pm/types": "^0.1.15",
+    "@pr-pm/registry-client": "^1.3.0",
+    "@pr-pm/types": "^0.2.0",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "commander": "^11.1.0",

package/schemas/prpm-manifest.schema.json

@@ -367,6 +367,100 @@
         "$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,
@@ -549,6 +643,58 @@
           ]
         }
       ]
+    },
+    {
+      "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"
+            }
+          ]
+        }
+      ]
     }
   ]
 }