prpm 0.0.7 → 0.0.8

package/dist/commands/search.js

@@ -44,67 +44,85 @@ const user_config_1 = require("../core/user-config");
 const telemetry_1 = require("../core/telemetry");
 const readline = __importStar(require("readline"));
 /**
- * Get icon for package type
+ * Get icon for package format and subtype
  */
-function getTypeIcon(type) {
-    const icons = {
-        skill: '🎓',
-        agent: '🤖',
-        command: '⚡',
+function getPackageIcon(format, subtype) {
+    // Subtype icons take precedence
+    const subtypeIcons = {
+        'skill': '🎓',
+        'agent': '🤖',
         'slash-command': '⚡',
-        'claude-slash-command': '⚡',
-        rule: '📋',
-        plugin: '🔌',
-        prompt: '💬',
-        workflow: '⚡',
-        tool: '🔧',
-        template: '📄',
-        mcp: '🔗',
+        'rule': '📋',
+        'prompt': '💬',
+        'workflow': '⚡',
+        'tool': '🔧',
+        'template': '📄',
+        'collection': '📦',
+        'chatmode': '💬',
     };
-    return icons[type] || '📦';
+    // Format-specific icons for rules/defaults
+    const formatIcons = {
+        'claude': '🤖',
+        'cursor': '📋',
+        'windsurf': '🌊',
+        'continue': '➡️',
+        'copilot': '✈️',
+        'kiro': '🎯',
+        'mcp': '🔗',
+        'agents.md': '📝',
+        'generic': '📦',
+    };
+    return subtypeIcons[subtype] || formatIcons[format] || '📦';
 }
 /**
- * Get human-readable label for package type
+ * Get human-readable label for package format and subtype
  */
-function getTypeLabel(type) {
-    const labels = {
-        skill: 'Skill',
-        agent: 'Agent',
-        command: 'Slash Command',
+function getPackageLabel(format, subtype) {
+    const formatLabels = {
+        'claude': 'Claude',
+        'cursor': 'Cursor',
+        'windsurf': 'Windsurf',
+        'continue': 'Continue',
+        'copilot': 'GitHub Copilot',
+        'kiro': 'Kiro',
+        'mcp': 'MCP',
+        'agents.md': 'Agents.md',
+        'generic': '',
+    };
+    const subtypeLabels = {
+        'skill': 'Skill',
+        'agent': 'Agent',
         'slash-command': 'Slash Command',
-        'claude-slash-command': 'Slash Command',
-        'claude-agent': 'Agent',
-        rule: 'Rule',
-        plugin: 'Plugin',
-        prompt: 'Prompt',
-        workflow: 'Workflow',
-        tool: 'Tool',
-        template: 'Template',
-        mcp: 'MCP Server',
+        'rule': 'Rule',
+        'prompt': 'Prompt',
+        'workflow': 'Workflow',
+        'tool': 'Tool',
+        'template': 'Template',
+        'collection': 'Collection',
+        'chatmode': 'Chat Mode',
     };
-    return labels[type] || type;
+    const formatLabel = formatLabels[format];
+    const subtypeLabel = subtypeLabels[subtype];
+    if (format === 'generic') {
+        return subtypeLabel;
+    }
+    return `${formatLabel} ${subtypeLabel}`;
 }
 /**
- * Map user-friendly CLI types to registry schema
+ * Map subtype filters for search
  */
-function mapTypeToRegistry(cliType) {
-    const typeMap = {
-        rule: { type: 'cursor', tags: ['cursor-rule'] },
-        // Skills are packages with type=claude-skill
-        skill: { type: 'claude-skill' },
-        // Agents are packages with type=claude-agent or claude (not claude-skill)
-        agent: { type: 'claude-agent' },
-        // Slash commands are packages with type=claude-slash-command
-        command: { type: 'claude-slash-command' },
-        'slash-command': { type: 'claude-slash-command' },
-        mcp: { type: 'mcp' },
-        plugin: { type: 'generic', tags: ['plugin'] },
-        prompt: { type: 'generic', tags: ['prompt'] },
-        workflow: { type: 'generic', tags: ['workflow'] },
-        tool: { type: 'generic', tags: ['tool'] },
-        template: { type: 'generic', tags: ['template'] },
-    };
-    return typeMap[cliType] || {};
+function buildSearchFilters(options) {
+    const searchOptions = {};
+    if (options.format) {
+        searchOptions.format = options.format;
+    }
+    if (options.subtype) {
+        searchOptions.subtype = options.subtype;
+    }
+    if (options.author) {
+        searchOptions.author = options.author;
+    }
+    return searchOptions;
 }
 /**
  * Build webapp URL for search results
@@ -114,8 +132,10 @@ function buildWebappUrl(query, options, page = 1) {
     const params = new URLSearchParams();
     if (query)
         params.append('q', query);
-    if (options.type)
-        params.append('type', options.type);
+    if (options.format)
+        params.append('format', options.format);
+    if (options.subtype)
+        params.append('subtype', options.subtype);
     if (options.author)
         params.append('author', options.author);
     if (page > 1)
@@ -137,8 +157,8 @@ function displayResults(packages, total, page, limit) {
         const downloads = pkg.total_downloads >= 1000
             ? `${(pkg.total_downloads / 1000).toFixed(1)}k`
             : pkg.total_downloads;
-        const typeIcon = getTypeIcon(pkg.type);
-        const typeLabel = getTypeLabel(pkg.type);
+        const typeIcon = getPackageIcon(pkg.format, pkg.subtype);
+        const typeLabel = getPackageLabel(pkg.format, pkg.subtype);
         // Add verified badge
         let verifiedBadge = '';
         if (pkg.featured || pkg.official || pkg.verified) {
@@ -254,29 +274,31 @@ async function handleSearch(query, options) {
     let result = null;
     let registryUrl = '';
     try {
-        // Allow empty query when filtering by type or author
+        // Allow empty query when filtering by format/subtype or author
         if (query) {
             console.log(`🔍 Searching for "${query}"...`);
         }
-        else if (options.type) {
-            console.log(`🔍 Listing ${options.type} packages...`);
+        else if (options.format || options.subtype) {
+            const filterType = options.subtype || options.format;
+            console.log(`🔍 Listing ${filterType} packages...`);
         }
         else if (options.author) {
             console.log(`🔍 Listing packages by @${options.author}...`);
         }
         else {
-            console.log('❌ Please provide a search query or use --type/--author to filter');
+            console.log('❌ Please provide a search query or use --format/--subtype/--author to filter');
             console.log('\n💡 Examples:');
             console.log('   prpm search react');
-            console.log('   prpm search --type skill');
+            console.log('   prpm search --subtype skill');
+            console.log('   prpm search --format claude');
             console.log('   prpm search --author prpm');
-            console.log('   prpm search react --type rule');
+            console.log('   prpm search react --subtype rule');
             return;
         }
         const config = await (0, user_config_1.getConfig)();
         registryUrl = config.registryUrl || 'https://registry.prpm.dev';
         const client = (0, registry_client_1.getRegistryClient)(config);
-        // Map CLI type to registry schema
+        // Build search options
         const limit = options.limit || 20;
         const page = options.page || 1;
         const offset = (page - 1) * limit;
@@ -284,14 +306,12 @@ async function handleSearch(query, options) {
             limit,
             offset,
         };
-        if (options.type) {
-            const mapped = mapTypeToRegistry(options.type);
-            if (mapped.type) {
-                searchOptions.type = mapped.type;
-            }
-            if (mapped.tags) {
-                searchOptions.tags = mapped.tags;
-            }
+        // Add format/subtype filters
+        if (options.format) {
+            searchOptions.format = options.format;
+        }
+        if (options.subtype) {
+            searchOptions.subtype = options.subtype;
         }
         if (options.author) {
             searchOptions.author = options.author;
@@ -359,7 +379,8 @@ async function handleSearch(query, options) {
             duration: Date.now() - startTime,
             data: {
                 query: query.substring(0, 100),
-                type: options.type,
+                format: options.format,
+                subtype: options.subtype,
                 resultCount: success && result ? result.packages.length : 0,
                 page: options.page,
                 interactive: options.interactive,
@@ -373,32 +394,41 @@ function createSearchCommand() {
     const command = new commander_1.Command('search');
     command
         .description('Search for packages in the registry')
-        .argument('[query]', 'Search query (optional when using --type or --author)')
-        .option('--type <type>', 'Filter by package type (skill, agent, command, slash-command, rule, plugin, prompt, workflow, tool, template, mcp)')
+        .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('--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')
         .option('--page <number>', 'Page number (default: 1)', '1')
         .option('--interactive', 'Enable interactive pagination (default: true for multiple pages)', true)
         .option('--no-interactive', 'Disable interactive pagination')
         .action(async (query, options) => {
-        const type = options.type;
+        const format = options.format;
+        const subtype = options.subtype;
         const author = options.author;
         const limit = options.limit ? parseInt(options.limit, 10) : 20;
         const page = options.page ? parseInt(options.page, 10) : 1;
-        const validTypes = ['skill', 'agent', 'command', 'slash-command', 'rule', 'plugin', 'prompt', 'workflow', 'tool', 'template', 'mcp'];
-        if (options.type && !validTypes.includes(type)) {
-            console.error(`❌ Type must be one of: ${validTypes.join(', ')}`);
+        const validFormats = ['cursor', 'claude', 'continue', 'windsurf', 'copilot', 'kiro', '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(', ')}`);
+            process.exit(1);
+        }
+        if (options.subtype && !validSubtypes.includes(subtype)) {
+            console.error(`❌ Subtype must be one of: ${validSubtypes.join(', ')}`);
             console.log(`\n💡 Examples:`);
-            console.log(`   prpm search postgres --type skill`);
-            console.log(`   prpm search debugging --type agent`);
-            console.log(`   prpm search refactor --type command`);
-            console.log(`   prpm search react --type rule`);
-            console.log(`   prpm search --type command  # List all slash commands`);
-            console.log(`   prpm search --type skill  # List all skills`);
-            console.log(`   prpm search --author prpm  # List packages by @pr-pm`);
+            console.log(`   prpm search postgres --subtype skill`);
+            console.log(`   prpm search debugging --subtype agent`);
+            console.log(`   prpm search refactor --subtype slash-command`);
+            console.log(`   prpm search react --subtype rule`);
+            console.log(`   prpm search --subtype slash-command  # List all slash commands`);
+            console.log(`   prpm search --subtype skill  # List all skills`);
+            console.log(`   prpm search --format claude  # List all Claude packages`);
+            console.log(`   prpm search --author prpm  # List packages by @prpm`);
             process.exit(1);
         }
-        await handleSearch(query || '', { type, author, limit, page, interactive: options.interactive });
+        await handleSearch(query || '', { format, subtype, author, limit, page, interactive: options.interactive });
+        process.exit(0);
     });
     return command;
 }

package/dist/commands/telemetry.js

@@ -33,6 +33,7 @@ function createStatusCommand() {
         else {
             console.log('\n💡 Telemetry is disabled. Run "prpm telemetry enable" to help improve the tool.');
         }
+        process.exit(0);
     });
 }
 function createEnableCommand() {
@@ -42,6 +43,7 @@ function createEnableCommand() {
         await telemetry_1.telemetry.enable();
         console.log('✅ Telemetry enabled');
         console.log('📊 Anonymous usage data will be collected to help improve the tool.');
+        process.exit(0);
     });
 }
 function createDisableCommand() {
@@ -51,6 +53,7 @@ function createDisableCommand() {
         await telemetry_1.telemetry.disable();
         console.log('❌ Telemetry disabled');
         console.log('📊 No usage data will be collected.');
+        process.exit(0);
     });
 }
 function createStatsCommand() {
@@ -63,6 +66,7 @@ function createStatsCommand() {
         if (stats.lastEvent) {
             console.log(`   Last event: ${stats.lastEvent}`);
         }
+        process.exit(0);
     });
 }
 function createTestCommand() {
@@ -98,6 +102,8 @@ function createTestCommand() {
         }
         catch (error) {
             console.error('❌ Failed to send test event:', error);
+            process.exit(1);
         }
+        process.exit(0);
     });
 }

package/dist/commands/trending.js

@@ -17,7 +17,7 @@ async function handleTrending(options) {
         console.log(`🔥 Fetching trending packages...`);
         const config = await (0, user_config_1.getConfig)();
         const client = (0, registry_client_1.getRegistryClient)(config);
-        const packages = await client.getTrending(options.type, options.limit || 10);
+        const packages = await client.getTrending(options.format, options.subtype, options.limit || 10);
         if (packages.length === 0) {
             console.log('\n❌ No trending packages found');
             return;
@@ -50,7 +50,8 @@ async function handleTrending(options) {
             error,
             duration: Date.now() - startTime,
             data: {
-                type: options.type,
+                format: options.format,
+                subtype: options.subtype,
                 limit: options.limit || 10,
             },
         });
@@ -61,16 +62,25 @@ function createTrendingCommand() {
     const command = new commander_1.Command('trending');
     command
         .description('Show trending packages')
-        .option('--type <type>', 'Filter by package type (cursor, claude, continue)')
+        .option('--format <format>', 'Filter by format (cursor, claude, continue, windsurf, copilot, kiro, 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 type = options.type;
+        const format = options.format;
+        const subtype = options.subtype;
         const limit = options.limit ? parseInt(options.limit, 10) : 10;
-        if (options.type && !['cursor', 'claude', 'continue', 'windsurf', 'generic'].includes(type)) {
-            console.error('❌ Type must be one of: cursor, claude, continue, windsurf, generic');
+        const validFormats = ['cursor', 'claude', 'continue', 'windsurf', 'copilot', 'kiro', '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(', ')}`);
             process.exit(1);
         }
-        await handleTrending({ type, limit });
+        if (options.subtype && !validSubtypes.includes(subtype)) {
+            console.error(`❌ Subtype must be one of: ${validSubtypes.join(', ')}`);
+            process.exit(1);
+        }
+        await handleTrending({ format, subtype, limit });
+        process.exit(0);
     });
     return command;
 }

package/dist/commands/uninstall.js

@@ -21,13 +21,10 @@ async function handleUninstall(name) {
             console.error(`❌ Package "${name}" not found`);
             process.exit(1);
         }
-        // Determine file path based on package type and format
-        const effectiveType = (pkg.format === 'claude' ? 'claude-skill' :
-            pkg.format === 'cursor' ? 'cursor' :
-                pkg.format === 'continue' ? 'continue' :
-                    pkg.format === 'windsurf' ? 'windsurf' :
-                        pkg.type);
-        const destDir = (0, filesystem_1.getDestinationDir)(effectiveType);
+        // Get destination directory using format and subtype
+        const format = pkg.format || 'generic';
+        const subtype = pkg.subtype || 'rule';
+        const destDir = (0, filesystem_1.getDestinationDir)(format, subtype);
         const fileExtension = pkg.format === 'cursor' ? 'mdc' : 'md';
         // Strip author namespace to get just the package name
         const packageName = (0, filesystem_1.stripAuthorNamespace)(name);

package/dist/commands/update.js

@@ -59,9 +59,7 @@ async function handleUpdate(packageName, options = {}) {
                 }
                 console.log(`\n📦 Updating ${pkg.id}: ${currentVersion} → ${latestVersion}`);
                 // Install new version
-                await (0, install_1.handleInstall)(`${pkg.id}@${latestVersion}`, {
-                    type: pkg.type,
-                });
+                await (0, install_1.handleInstall)(`${pkg.id}@${latestVersion}`, {});
                 updatedCount++;
             }
             catch (err) {
@@ -117,5 +115,8 @@ function createUpdateCommand() {
         .description('Update packages to latest compatible versions (minor/patch only)')
         .argument('[package]', 'Specific package to update (optional)')
         .option('--all', 'Update all packages')
-        .action(handleUpdate);
+        .action(async (packageName, options) => {
+        await handleUpdate(packageName, options);
+        process.exit(0);
+    });
 }

package/dist/commands/upgrade.js

@@ -58,9 +58,7 @@ async function handleUpgrade(packageName, options = {}) {
                     console.log(`   ⚠️  This is a major version upgrade and may contain breaking changes`);
                 }
                 // Install new version
-                await (0, install_1.handleInstall)(`${pkg.id}@${latestVersion}`, {
-                    type: pkg.type,
-                });
+                await (0, install_1.handleInstall)(`${pkg.id}@${latestVersion}`, {});
                 upgradedCount++;
             }
             catch (err) {
@@ -117,5 +115,8 @@ function createUpgradeCommand() {
         .argument('[package]', 'Specific package to upgrade (optional)')
         .option('--all', 'Upgrade all packages')
         .option('--force', 'Skip warning for major version upgrades')
-        .action(handleUpgrade);
+        .action(async (packageName, options) => {
+        await handleUpgrade(packageName, options);
+        process.exit(0);
+    });
 }

package/dist/commands/whoami.js

@@ -45,7 +45,13 @@ async function handleWhoami() {
         }
         catch (apiError) {
             // Fallback to simple username display if API call fails
+            // This can happen if the user's token is stale or the registry is unavailable
             console.log(`${config.username}`);
+            // Show hint if it looks like an auth issue
+            const errorMessage = apiError instanceof Error ? apiError.message : String(apiError);
+            if (errorMessage.includes('User not found') || errorMessage.includes('Unauthorized')) {
+                console.log('💡 Tip: Your token may be outdated. Run "prpm login" to refresh.\n');
+            }
         }
         success = true;
     }
@@ -71,5 +77,8 @@ async function handleWhoami() {
 function createWhoamiCommand() {
     return new commander_1.Command('whoami')
         .description('Show current logged-in user')
-        .action(handleWhoami);
+        .action(async () => {
+        await handleWhoami();
+        process.exit(0);
+    });
 }

package/dist/core/filesystem.js

@@ -16,32 +16,38 @@ exports.stripAuthorNamespace = stripAuthorNamespace;
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 /**
- * Get the destination directory for a package type
+ * Get the destination directory for a package based on format and subtype
  */
-function getDestinationDir(type) {
-    switch (type) {
+function getDestinationDir(format, subtype) {
+    switch (format) {
         case 'cursor':
+            if (subtype === 'agent')
+                return '.cursor/agents';
+            if (subtype === 'slash-command')
+                return '.cursor/commands';
             return '.cursor/rules';
-        case 'cursor-agent':
-            return '.cursor/agents';
-        case 'cursor-slash-command':
-            return '.cursor/commands';
         case 'claude':
-            return '.claude/agents';
-        case 'claude-agent':
-            return '.claude/agents';
-        case 'claude-skill':
-            return '.claude/skills';
-        case 'claude-slash-command':
-            return '.claude/commands';
+            if (subtype === 'skill')
+                return '.claude/skills';
+            if (subtype === 'slash-command')
+                return '.claude/commands';
+            if (subtype === 'agent')
+                return '.claude/agents';
+            return '.claude/agents'; // Default for claude
         case 'continue':
             return '.continue/rules';
         case 'windsurf':
             return '.windsurf/rules';
+        case 'copilot':
+            return '.github/instructions';
+        case 'kiro':
+            return '.kiro/steering';
         case 'generic':
             return '.prompts';
+        case 'mcp':
+            return '.mcp/tools';
         default:
-            throw new Error(`Unknown package type: ${type}`);
+            throw new Error(`Unknown format: ${format}`);
     }
 }
 /**

package/dist/core/lockfile.js

@@ -72,8 +72,8 @@ function addToLockfile(lockfile, packageId, packageInfo) {
         resolved: packageInfo.tarballUrl,
         integrity: '', // Will be set after download
         dependencies: packageInfo.dependencies,
-        type: packageInfo.type,
         format: packageInfo.format,
+        subtype: packageInfo.subtype,
         installedPath: packageInfo.installedPath,
     };
     lockfile.generated = new Date().toISOString();
@@ -194,8 +194,8 @@ async function addPackage(packageInfo) {
         version: packageInfo.version,
         tarballUrl: packageInfo.tarballUrl,
         dependencies: packageInfo.dependencies,
-        type: packageInfo.type,
         format: packageInfo.format,
+        subtype: packageInfo.subtype,
         installedPath: packageInfo.installedPath,
     });
     await writeLockfile(lockfile);

package/dist/core/marketplace-converter.js

@@ -25,16 +25,20 @@ function marketplaceToManifest(marketplace, pluginIndex = 0) {
         throw new Error(`Plugin index ${pluginIndex} out of range. Found ${marketplace.plugins.length} plugins.`);
     }
     const plugin = marketplace.plugins[pluginIndex];
-    // Determine package type based on what the plugin contains
-    let type = 'claude';
+    // Determine package format and subtype based on what the plugin contains
+    let format = 'claude';
+    let subtype = 'rule';
     if (plugin.agents && plugin.agents.length > 0) {
-        type = 'claude';
+        format = 'claude';
+        subtype = 'agent';
     }
     else if (plugin.skills && plugin.skills.length > 0) {
-        type = 'claude';
+        format = 'claude';
+        subtype = 'skill';
     }
     else if (plugin.commands && plugin.commands.length > 0) {
-        type = 'claude';
+        format = 'claude';
+        subtype = 'slash-command';
     }
     // Generate package name from plugin name
     // Format: @owner/plugin-name
@@ -54,7 +58,8 @@ function marketplaceToManifest(marketplace, pluginIndex = 0) {
         name: packageName,
         version: plugin.version || marketplace.version || '1.0.0',
         description: plugin.description || marketplace.description,
-        type,
+        format,
+        subtype,
         author: plugin.author || marketplace.owner,
         files,
         tags,

package/dist/core/registry-client.js

@@ -16,8 +16,10 @@ class RegistryClient {
      */
     async search(query, options) {
         const params = new URLSearchParams({ q: query });
-        if (options?.type)
-            params.append('type', options.type);
+        if (options?.format)
+            params.append('format', options.format);
+        if (options?.subtype)
+            params.append('subtype', options.subtype);
         if (options?.tags)
             options.tags.forEach(tag => params.append('tags', tag));
         if (options?.limit)
@@ -87,10 +89,12 @@ class RegistryClient {
     /**
      * Get trending packages
      */
-    async getTrending(type, limit = 20) {
+    async getTrending(format, subtype, limit = 20) {
         const params = new URLSearchParams({ limit: limit.toString() });
-        if (type)
-            params.append('type', type);
+        if (format)
+            params.append('format', format);
+        if (subtype)
+            params.append('subtype', subtype);
         const response = await this.fetch(`/api/v1/search/trending?${params}`);
         const data = await response.json();
         return data.packages;
@@ -98,10 +102,12 @@ class RegistryClient {
     /**
      * Get featured packages
      */
-    async getFeatured(type, limit = 20) {
+    async getFeatured(format, subtype, limit = 20) {
         const params = new URLSearchParams({ limit: limit.toString() });
-        if (type)
-            params.append('type', type);
+        if (format)
+            params.append('format', format);
+        if (subtype)
+            params.append('subtype', subtype);
         const response = await this.fetch(`/api/v1/search/featured?${params}`);
         const data = await response.json();
         return data.packages;